public bool IsPluginNeeded([NotNull] IProject project)
{
var assetsDir = GetAssetsDirectory(project);
if (assetsDir == null)
{
return(false); // not a Unity project
}
var jetBrainsDir = assetsDir
.CombineWithShortName("Plugins")
.CombineWithShortName("Editor")
.CombineWithShortName("JetBrains");
if (!jetBrainsDir.ExistsDirectory)
{
return(true);
}
var existingFiles = new JetHashSet <string>(jetBrainsDir.GetChildFiles().Select(f => f.Name));
return(ourPluginFiles.Any(f => !existingFiles.Contains(f)));
}
private ISymbolTable GetSymbolTable(HtmlCodeCompletionContext context)
{
var completeableReference = context.Reference as ICompletableReference;
var smartCompleteableReference = completeableReference as IHtmlSmartCompletableReference;
ISymbolTable symbolTable;
if (context.BasicContext.CodeCompletionType == CodeCompletionType.SmartCompletion &&
smartCompleteableReference != null)
{
symbolTable = smartCompleteableReference.GetSmartCompletionSymbolTable();
}
else if (completeableReference != null)
{
symbolTable = completeableReference.GetCompletionSymbolTable();
}
else
{
return(EmptySymbolTable.INSTANCE);
}
if (context.Reference is IHtmlAttributeReference && context.TreeNode != null)
{
var header = context.TreeNode.GetContainingNode <IHtmlTagHeader>();
var node = context.BasicContext.File.FindNodeAt(context.BasicContext.CaretDocumentOffset);
if (node != null && header != null)
{
node = node.GetContainingNode <ITagAttribute>(true);
var existingNames = new JetHashSet <string>(
header.Attributes.Where(attribute => attribute != node).Select(arg => arg.AttributeName), StringComparer.OrdinalIgnoreCase);
symbolTable = symbolTable.Filter(new ExistingNamesFilter(existingNames));
}
}
return(symbolTable.Filter(new PredicateFilter(symbol =>
{
return Abbreviations.Any(a => symbol.ShortName.StartsWith(a));
})));
}
protected override bool AddLookupItems(T4CodeCompletionContext context, IItemsCollector collector)
{
ITreeNode node = context.BasicContext.File.FindNodeAt(context.BasicContext.SelectedTreeRange);
Assertion.AssertNotNull(node, "node == null");
var ranges = context.BasicContext.GetRanges(node);
collector.AddRanges(ranges);
var directive = node.GetContainingNode <IT4Directive>();
Assertion.AssertNotNull(directive, "directive != null");
DirectiveInfo directiveInfo = _directiveInfoManager.GetDirectiveByName(directive.GetName());
if (directiveInfo == null)
{
return(false);
}
JetHashSet <string> existingNames = directive
.GetAttributes()
.Select(attr => attr.GetName())
.ToJetHashSet(s => s, StringComparer.OrdinalIgnoreCase);
foreach (string attributeName in directiveInfo.SupportedAttributes.Select(attr => attr.Name))
{
if (existingNames.Contains(attributeName))
{
continue;
}
var item = new TextLookupItem(attributeName);
item.InitializeRanges(ranges, context.BasicContext);
collector.Add(item);
}
return(true);
}
public UnityExternalFilesModuleProcessor(Lifetime lifetime, ILogger logger, ISolution solution,
ChangeManager changeManager,
IShellLocks locks,
ISolutionLoadTasksScheduler scheduler,
IFileSystemTracker fileSystemTracker,
ProjectFilePropertiesFactory projectFilePropertiesFactory,
UnityYamlPsiSourceFileFactory psiSourceFileFactory,
UnityExternalFilesModuleFactory moduleFactory,
UnityYamlDisableStrategy unityYamlDisableStrategy,
ISettingsSchema settingsSchema,
SettingsLayersProvider settingsLayersProvidert)
{
myLifetime = lifetime;
myLogger = logger;
mySolution = solution;
myChangeManager = changeManager;
myLocks = locks;
myFileSystemTracker = fileSystemTracker;
myProjectFilePropertiesFactory = projectFilePropertiesFactory;
myPsiSourceFileFactory = psiSourceFileFactory;
myModuleFactory = moduleFactory;
myUnityYamlDisableStrategy = unityYamlDisableStrategy;
changeManager.RegisterChangeProvider(lifetime, this);
myRootPaths = new JetHashSet <FileSystemPath>();
// SolutionDirectory isn't absolute in tests, and will throw an exception if we use it when we call Exists
mySolutionDirectory = solution.SolutionDirectory;
if (!mySolutionDirectory.IsAbsolute)
{
mySolutionDirectory = solution.SolutionDirectory.ToAbsolutePath(FileSystemUtil.GetCurrentDirectory());
}
scheduler.EnqueueTask(new SolutionLoadTask(GetType().Name + ".Activate",
SolutionLoadTaskKinds.PreparePsiModules,
() => myChangeManager.AddDependency(myLifetime, mySolution.PsiModules(), this)));
}
object IChangeProvider.Execute(IChangeMap changeMap)
{
var projectModelChange = changeMap.GetChange <ProjectModelChange>(mySolution);
if (projectModelChange == null)
{
return(null);
}
// ReSharper hasn't necessarily processed all references when it adds the IProject
// to the IViewableProjectsCollection. Keep an eye on reference changes, add the
// project settings if/when the project becomes a unity project
var projects = new JetHashSet <IProject>();
var changes = ReferencedAssembliesService.TryGetAssemblyReferenceChanges(projectModelChange, ProjectExtensions.UnityReferenceNames);
foreach (var change in changes)
{
if (change.IsAdded)
{
var project = change.GetNewProject();
if (project.IsUnityProject())
{
projects.Add(project);
}
}
}
foreach (var project in projects)
{
myChangeManager.ExecuteAfterChange(() =>
{
Handle(project);
});
}
return(null);
}
public UnityPluginInstaller(
Lifetime lifetime,
ILogger logger,
ISolution solution,
IShellLocks shellLocks,
UnityPluginDetector detector,
RdNotificationsModel notifications,
ISettingsStore settingsStore,
PluginPathsProvider pluginPathsProvider)
{
myPluginInstallations = new JetHashSet <FileSystemPath>();
myLifetime = lifetime;
myLogger = logger;
mySolution = solution;
myShellLocks = shellLocks;
myDetector = detector;
myNotifications = notifications;
myPluginPathsProvider = pluginPathsProvider;
myBoundSettingsStore = settingsStore.BindToContextLive(myLifetime, ContextRange.Smart(solution.ToDataContext()));
myQueue = new ProcessingQueue(myShellLocks, myLifetime);
}
// Return a context object for the item being searched for, or null if the element isn't interesting.
// CanContainReferences isn't called if we return null. Do the work once here, then use it multiple times for
// each file in CanContainReferences
public object GetElementId(IDeclaredElement element)
{
if (!UnityYamlUsageSearchFactory.IsInterestingElement(element))
{
return(null);
}
var set = new JetHashSet <IPsiSourceFile>();
switch (element)
{
case IClass _class:
foreach (var sourceFile in myAssetUsagesElementContainer.GetPossibleFilesWithUsage(_class))
{
set.Add(sourceFile);
}
break;
case IProperty _:
case IMethod _:
foreach (var sourceFile in myAssetMethodsElementContainer.GetPossibleFilesWithUsage(element))
{
set.Add(sourceFile);
}
break;
case IField field:
foreach (var sourceFile in myInspectorValuesContainer.GetPossibleFilesWithUsage(field))
{
set.Add(sourceFile);
}
break;
}
return(new UnityYamlSearchGuruId(set));
}
private List <string> InitElementsMap(IEnumerable <IUnitTestElement> unitTestElements,
Dictionary <string, IUnitTestElement> elementToIdMap)
{
var result = new JetHashSet <string>();
foreach (var unitTestElement in unitTestElements)
{
if (unitTestElement is NUnitTestElement)
{
var unityName = string.Format(unitTestElement.Id);
elementToIdMap[unityName] = unitTestElement;
result.Add(unityName);
}
if (unitTestElement is UnityTestElement)
{
var unityName = string.Format(unitTestElement.Id);
elementToIdMap[unityName] = unitTestElement;
result.Add(unityName);
}
}
return(result.ToList());
}
object IChangeProvider.Execute(IChangeMap changeMap)
{
var projectModelChange = changeMap.GetChange <ProjectModelChange>(mySolution);
if (projectModelChange == null)
{
return(null);
}
var changes = ReferencedAssembliesService.TryGetAssemblyReferenceChanges(projectModelChange,
ProjectExtensions.UnityReferenceNames, myLogger);
var newUnityProjects = new JetHashSet <IProject>();
foreach (var change in changes)
{
if (change.IsAdded)
{
var project = change.GetNewProject();
if (project.IsUnityProject())
{
newUnityProjects.Add(project);
}
}
}
myChangeManager.ExecuteAfterChange(() =>
{
foreach (var project in newUnityProjects)
{
OnUnityProjectAdded(project);
}
});
return(null);
}
public UnityPluginInstaller(
Lifetime lifetime,
ILogger logger,
ISolution solution,
IShellLocks shellLocks,
UnityPluginDetector detector,
RdNotificationsModel notifications,
ISettingsStore settingsStore,
ProjectReferenceChangeTracker changeTracker)
{
myPluginInstallations = new JetHashSet <FileSystemPath>();
myLifetime = lifetime;
myLogger = logger;
mySolution = solution;
myShellLocks = shellLocks;
myDetector = detector;
myNotifications = notifications;
myBoundSettingsStore = settingsStore.BindToContextLive(myLifetime, ContextRange.Smart(solution.ToDataContext()));
BindToInstallationSettingChange();
changeTracker.RegisterProjectChangeHandler(InstallPluginIfRequired);
}
public CgSyntaxHighlightingProcess(IDaemonProcess daemonProcess, IContextBoundSettingsStore settingsStore, ICgFile file, bool isErrorHighlightingEnabled, JetHashSet <string> semantics)
#if RIDER
: base(daemonProcess, file)
#else
: base(daemonProcess, settingsStore, file)
protected override bool AddLookupItems(CSharpCodeCompletionContext context, GroupedItemsCollector collector)
{
var settingsStore = context.BasicContext.File.GetSettingsStore();
if (!settingsStore.GetValue(PostfixSettingsAccessor.ShowPostfixItems))
{
return(false);
}
var executionContext = new ReparsedPostfixExecutionContext(myLifetime, context.BasicContext, context.UnterminatedContext, "__");
var postfixContext = myTemplatesManager.IsAvailable(context.UnterminatedContext.TreeNode, executionContext);
if (postfixContext == null) // try unterminated context if terminated sucks
{
executionContext = new ReparsedPostfixExecutionContext(myLifetime, context.BasicContext, context.TerminatedContext, "__;");
postfixContext = myTemplatesManager.IsAvailable(context.TerminatedContext.TreeNode, executionContext);
}
if (postfixContext == null)
{
return(false);
}
// nothing to check :(
if (postfixContext.Expressions.Count == 0 && postfixContext.TypeExpression == null)
{
return(false);
}
var lookupItems = myTemplatesManager.CollectItems(postfixContext);
if (lookupItems.Count == 0)
{
return(false);
}
ICollection <string> toRemove = EmptyList <string> .InstanceList;
// double completion support
var parameters = context.BasicContext.Parameters;
var isDoubleCompletion = (parameters.CodeCompletionTypes.Length > 1);
if (!executionContext.IsAutoCompletion && isDoubleCompletion)
{
var firstCompletion = parameters.CodeCompletionTypes[0];
if (firstCompletion != CodeCompletionType.AutomaticCompletion)
{
return(false);
}
// run postfix templates like we are in auto completion
executionContext.IsAutoCompletion = true;
var automaticPostfixItems = myTemplatesManager.CollectItems(postfixContext);
if (automaticPostfixItems.Count > 0)
{
toRemove = new JetHashSet <string>(StringComparer.Ordinal);
foreach (var lookupItem in automaticPostfixItems)
{
toRemove.Add(lookupItem.Identity);
}
}
}
foreach (var lookupItem in lookupItems)
{
if (toRemove.Contains(lookupItem.Identity))
{
continue;
}
if (isDoubleCompletion)
{
collector.AddToTop(lookupItem);
}
else
{
collector.AddSomewhere(lookupItem);
}
}
return(lookupItems.Count > 0);
}
public Dictionary <int, Dictionary <string, IAssetValue> > GetImportedValuesForUnityEvent(LocalReference scriptLocation, JetHashSet <string> allUnityEventNames)
{
var result = new Dictionary <int, Dictionary <string, IAssetValue> >();
foreach (var modification in myPrefabInstanceHierarchy.PrefabModifications)
{
if (!(modification.Target is ExternalReference externalReference))
{
continue;
}
if (!modification.PropertyPath.Contains("m_PersistentCalls"))
{
continue;
}
var location = new LocalReference(Location.OwningPsiPersistentIndex, PrefabsUtil.GetImportedDocumentAnchor(myPrefabInstanceHierarchy.Location.LocalDocumentAnchor, externalReference.LocalDocumentAnchor));
if (!location.Equals(scriptLocation))
{
continue;
}
var parts = modification.PropertyPath.Split('.');
var unityEventName = parts[0];
if (!allUnityEventNames.Contains(unityEventName))
{
continue;
}
var dataPart = parts.FirstOrDefault(t => t.StartsWith("data"));
if (dataPart == null)
{
continue;
}
if (!int.TryParse(dataPart.RemoveStart("data[").RemoveEnd("]"), out var index))
{
continue;
}
var last = parts.Last();
if (!result.TryGetValue(index, out var modifications))
{
modifications = new Dictionary <string, IAssetValue>();
result[index] = modifications;
}
switch (last)
{
case "m_Mode" when modification.Value is AssetSimpleValue simpleValue:
modifications[last] = simpleValue;
break;
case "m_MethodName" when modification.Value is AssetSimpleValue simpleValue:
modifications[last] = simpleValue;
modifications["m_MethodNameRange"] = new Int2Value(modification.ValueRange.StartOffset, modification.ValueRange.EndOffset);
break;
case "m_Target" when modification.ObjectReference is IHierarchyReference objectReference:
modifications[last] = new AssetReferenceValue(objectReference);
break;
}
}
return(result);
}
public NitraTextOccurenceSearcher(IEnumerable <string> texts)
{
myTexts = new JetHashSet <string>(texts.Where(value => !string.IsNullOrEmpty(value)));
}
public CgSyntaxHighlightingProcess(IDaemonProcess daemonProcess, ICgFile file, bool isErrorHighlightingEnabled, JetHashSet <string> semantics)
: base(daemonProcess, file)
{
myIsErrorHighlightingEnabled = isErrorHighlightingEnabled;
mySemantics = semantics;
}
public UnityYamlSearchGuruId(JetHashSet <IPsiSourceFile> files)
{
Files = files;
}
private ISearchDomain NarrowSearchDomain(ISolution solution, IEnumerable<string> words, IEnumerable<string> extendedWords, ISearchDomain domain)
{
List<string> allWords = words.ToList();
List<string> allExtendedWords = extendedWords.ToList();
if (domain.IsEmpty || allWords.IsEmpty())
return domain;
IWordIndex wordIndex = solution.GetPsiServices().CacheManager.WordIndex;
var jetHashSet1 = new JetHashSet<IPsiSourceFile>(wordIndex.GetFilesContainingWord(allWords.First()), null);
foreach (string word in allWords.Skip(1))
jetHashSet1.IntersectWith(wordIndex.GetFilesContainingWord(word));
if (allExtendedWords.Any())
{
var jetHashSet2 = new JetHashSet<IPsiSourceFile>(null);
using (JetHashSet<IPsiSourceFile>.ElementEnumerator enumerator = jetHashSet1.GetEnumerator())
{
while (enumerator.MoveNext())
{
IPsiSourceFile file = enumerator.Current;
if (allExtendedWords.Any(word => wordIndex.CanContainWord(file, word)))
jetHashSet2.Add(file);
}
}
jetHashSet1 = jetHashSet2;
}
return domain.Intersect(searchDomainFactory.CreateSearchDomain(jetHashSet1));
}
public IEnumerable <string> GetAllPossibleWordsInFile(IDeclaredElement element)
{
var names = new JetHashSet <string>();
var constructor = element as IConstructor;
if (constructor != null)
{
ITypeElement typeElement = constructor.GetContainingType();
if (typeElement != null)
{
names.Add(typeElement.ShortName);
}
names.Add(DeclaredElementConstants.CONSTRUCTOR_NAME);
return(names);
}
names.Add(element.ShortName);
if (PsiDeclaredElementUtil.IsCollectionInitializerAddMethod(element))
{
names.Add("new");
}
if (PsiDeclaredElementUtil.IsForeachEnumeratorPatternMember(element))
{
names.Add("foreach");
}
if (DeclaredElementUtil.IsAsyncAwaitablePatternMember(element))
{
names.Add("async");
names.Add("await");
}
// LINQ
var method = element as IMethod;
if (method != null)
{
if (method.ShortName == "Cast" && method.TypeParameters.Count == 1 && IsCorrectParametersNumberForQueryPatternMethod(method, 0))
{
names.Add("from");
}
if (method.ShortName == "Select" && IsCorrectParametersNumberForQueryPatternMethod(method, 1))
{
names.Add("from");
}
if (method.ShortName == "SelectMany" && IsCorrectParametersNumberForQueryPatternMethod(method, 2))
{
names.Add("from");
}
if (method.ShortName == "Where" && IsCorrectParametersNumberForQueryPatternMethod(method, 1))
{
names.Add("where");
}
if ((method.ShortName == "Join" || method.ShortName == "GroupJoin") && IsCorrectParametersNumberForQueryPatternMethod(method, 4))
{
names.Add("join");
}
if ((method.ShortName == "OrderBy" || method.ShortName == "OrderByDescending" || method.ShortName == "ThenBy" || method.ShortName == "ThenByDescending") && IsCorrectParametersNumberForQueryPatternMethod(method, 1))
{
names.Add("orderby");
}
if (method.ShortName == "GroupBy" && (IsCorrectParametersNumberForQueryPatternMethod(method, 1) || IsCorrectParametersNumberForQueryPatternMethod(method, 2)))
{
names.Add("group");
}
}
return(names);
}
public List <Dictionary <string, IAssetValue> > ImportUnityEventData(UnityEventsElementContainer elementContainer, JetHashSet <string> allUnityEventNames)
{
var result = myScriptComponentHierarchy.ImportUnityEventData(elementContainer, allUnityEventNames);
var patchData = GetImportedValuesForUnityEvent(Location, allUnityEventNames);
var maxValue = patchData.Keys.Count == 0 ? 0 : patchData.Keys.Max();
while (maxValue >= result.Count)
{
result.Add(new Dictionary <string, IAssetValue>());
}
foreach (var(i, patch) in patchData)
{
AssetUtils.Import(result[i], patch);
}
return(result);
}
static Processor()
{
// Also $injector.get and $injector.invoke
InjectableNames = new JetHashSet<string> {"controller", "directive", "filter", "factory", "service", "provider", "animation" };
}
protected override IEnumerable <ILookupItem> GetItemsFromResult(ICodeCompletionResult result, JetHashSet <ILookupItem> best)
{
return(base.GetItemsFromResult(result, best).OfType <ReflectionMemberLookupItem>());
}
/// <summary>
/// This code changes PSI documents. It is executed usder PSI transaction, Command cookies, Reentrancy guard ets.
/// All documents are committed (PSI is valid).
/// </summary>
public override bool Execute(IProgressIndicator pi)
{
pi.Start(6);
//check if data stored in workflow is valid...
Method = Workflow.MethodPointer.FindDeclaredElement();
Parameter = Workflow.ParameterPointer.FindDeclaredElement();
if (Method == null || Parameter == null)
{
return(false);
}
IPsiServices services = Parameter.GetPsiServices();
IReference[] referencesToParameter;
IReference[] referencesToRootOverrides;
// search for method overrides (OverridesFinder is util class that
// allows to find all overrides and problems with quasi implementations)
OverridesFinder overridesFinder = OverridesFinder.CreateInstance(Method);
using (var subPi = new SubProgressIndicator(pi, 1))
overridesFinder.Find(subPi);
JetHashSet <HierarchyMember> hierarchyMembers = overridesFinder.Overrides;
List <IMethod> methods = ScanHierarchyConflicts(hierarchyMembers).ToList();
List <IParameter> parameters = GetAllParameters(methods).ToList();
// find parameters and methods usages...
using (var subPi = new SubProgressIndicator(pi, 1))
{
subPi.TaskName = "Searching parameter usages:";
IEnumerable <IPsiSourceFile> projectFiles = from param in parameters
let projectFilesOfOneParameter = param.GetSourceFiles()
from projectFile in projectFilesOfOneParameter
select projectFile;
ISearchDomain searchDomain = mySearchDomainFactory.CreateSearchDomain(projectFiles.ToList());
referencesToParameter = services.Finder.FindReferences(parameters, searchDomain, subPi);
}
using (var subPi = new SubProgressIndicator(pi, 1))
{
subPi.TaskName = "Searching method usages:";
referencesToRootOverrides = services.Finder.FindReferences(methods,
mySearchDomainFactory.CreateSearchDomain(Solution,
false), subPi);
}
// this step processes method usages, removes argument and stores reference specific data to the 'MethodInvocation'.
List <MethodInvocation> usages;
using (var subPi = new SubProgressIndicator(pi, 1))
usages = PreProcessMethodUsages(referencesToRootOverrides, subPi).ToList();
// replace usages of parameters with typeof(TNewTypeParameter) expression.
using (var subPi = new SubProgressIndicator(pi, 1))
ProcessParameterUsages(referencesToParameter, subPi);
// Remove parameters from method declarations and insert new type parmeter. Map contains method -> new type parameter relation.
Dictionary <IMethod, ITypeParameter> map = UpdateDeclarations(methods);
// We have changed declarations. cashes should be updated)
PsiManager.GetInstance(Solution).UpdateCaches();
// Process method usages one more time to insert correct type arguments to the call.
using (var subPi = new SubProgressIndicator(pi, 1))
BindUsages(usages, map, subPi);
return(true);
}
public void Execute(IDataContext context, DelegateExecute nextExecute)
{
var solution = context.GetData(ProjectModelDataConstants.SOLUTION);
if (solution == null)
{
return;
}
var wordsPerAssembly = new OneToSetMap <string, string>(valueComparer: StringComparer.InvariantCultureIgnoreCase);
var abbreviations = new JetHashSet <string>();
// TODO: This should be in a background task
var psiModules = solution.GetComponent <IPsiModules>();
var symbolCache = solution.GetComponent <ISymbolCache>();
foreach (var assemblyPsiModule in psiModules.GetAssemblyModules().OrderBy(m => m.DisplayName))
{
if (!ShouldProcessAssembly(assemblyPsiModule))
{
continue;
}
var symbolScope = symbolCache.GetSymbolScope(assemblyPsiModule, false, true);
var typeElements = symbolScope.GetAllTypeElementsGroupedByName();
foreach (var typeElement in typeElements)
{
if (!typeElement.CanBeVisibleToSolution())
{
continue;
}
AddWords(wordsPerAssembly, abbreviations, assemblyPsiModule, typeElement.ShortName);
foreach (var namespaceName in typeElement.GetClrName().NamespaceNames)
{
AddWords(wordsPerAssembly, abbreviations, assemblyPsiModule, namespaceName);
}
// TODO: Should we skip enum values?
// It's unlikely that a user would name a method or variable after a value such as AdvertisingNetwork.Aarki,
// but on the other hand, if it's used in a comment, it'll show up as a typo.
foreach (var typeMember in typeElement.GetMembers())
{
if (!ShouldProcessTypeMember(typeMember))
{
continue;
}
if (typeElement is IEnum)
{
// Don't use any enum values as abbreviations. Avoids false positives with ALL_UPPER_CASE style
AddWords(wordsPerAssembly, new JetHashSet <string>(), assemblyPsiModule,
typeMember.ShortName);
}
else
{
AddWords(wordsPerAssembly, abbreviations, assemblyPsiModule, typeMember.ShortName);
}
// TODO: Include parameter names?
// Respeller will not check parameter names of overriding or implementing functions, so this is
// probably unnecessary
}
}
}
// Case insensitive. There will not be duplicates
var allWords = (from pair in wordsPerAssembly
from word in pair.Value
select word).ToJetHashSet(StringComparer.InvariantCultureIgnoreCase);
var spellService = solution.GetComponent <ISpellService>();
var unknownWords = (from word in allWords
where !spellService.CheckWordSpelling(word)
select word).ToJetHashSet(StringComparer.InvariantCultureIgnoreCase);
// Add abbreviations separately. If added to the dictionary, we don't get typo warnings, but we can get
// naming standard inspection warnings. E.g. BlahBlahAABB is converted to BlahBlahAabb. Don't add anything
// that's already known, but the spell checker will only check for words of 4 characters or more.
// TODO: Ideally, we should disable AbbreviationsSettingsProvider. But just merge results in for now
var unknownAbbreviations = (from word in abbreviations
where (word.Length > 1 && word.Length < 4) || !spellService.CheckWordSpelling(word)
select word).ToJetHashSet();
// Remove the non-abbreviations
unknownAbbreviations.Remove("TEXTMESHPRO");
unknownAbbreviations.Remove("GRAIDENT");
// Remove known typos or exclusions. Yes, this is all done by hand
RemoveTyposAndExclusions(unknownWords);
// Dump all words for diagnostics
Dumper.DumpToNotepad(w =>
{
w.WriteLine("All words");
w.WriteLine();
foreach (var(assembly, words) in wordsPerAssembly)
{
w.WriteLine("Words for assembly: " + assembly);
w.WriteLine();
foreach (var word in words.OrderBy(IdentityFunc <string> .Instance))
{
w.WriteLine(word.ToLowerInvariant());
}
w.WriteLine();
}
});
// Dump all abbreviations, so we can avoid naming standards inspections when an abbreviation is used.
// E.g. BlahBlahAABB is accepted instead of converted to BlahBlahAabb
Dumper.DumpToNotepad(w =>
{
w.WriteLine("Abbreviations");
w.WriteLine();
foreach (var abbreviation in unknownAbbreviations.OrderBy(IdentityFunc <string> .Instance))
{
w.WriteLine(abbreviation.ToUpperInvariant());
}
});
// Dump all unknown words, minus abbreviations, for use as a dictionary
Dumper.DumpToNotepad(w =>
{
var dictionary = new JetHashSet <string>(unknownWords, StringComparer.InvariantCultureIgnoreCase);
dictionary.ExceptWith(abbreviations);
w.WriteLine("Dictionary (unknown words minus abbreviations)");
w.WriteLine();
w.WriteLine(dictionary.Count); // Hunspell dictionaries start with the number of words
foreach (var word in dictionary.OrderBy(IdentityFunc <string> .Instance))
{
w.WriteLine(word.ToLowerInvariant());
}
});
}
public IEnumerable<string> GetAllPossibleWordsInFile(IDeclaredElement element)
{
var names = new JetHashSet<string>();
var constructor = element as IConstructor;
if (constructor != null)
{
ITypeElement typeElement = constructor.GetContainingType();
if (typeElement != null)
{
names.Add(typeElement.ShortName);
}
names.Add(DeclaredElementConstants.CONSTRUCTOR_NAME);
return names;
}
names.Add(element.ShortName);
if (PsiDeclaredElementUtil.IsCollectionInitializerAddMethod(element))
{
names.Add("new");
}
if (PsiDeclaredElementUtil.IsForeachEnumeratorPatternMember(element))
{
names.Add("foreach");
}
if (DeclaredElementUtil.IsAsyncAwaitablePatternMember(element))
{
names.Add("async");
names.Add("await");
}
// LINQ
var method = element as IMethod;
if (method != null)
{
if (method.ShortName == "Cast" && method.TypeParameters.Count == 1 && IsCorrectParametersNumberForQueryPatternMethod(method, 0))
{
names.Add("from");
}
if (method.ShortName == "Select" && IsCorrectParametersNumberForQueryPatternMethod(method, 1))
{
names.Add("from");
}
if (method.ShortName == "SelectMany" && IsCorrectParametersNumberForQueryPatternMethod(method, 2))
{
names.Add("from");
}
if (method.ShortName == "Where" && IsCorrectParametersNumberForQueryPatternMethod(method, 1))
{
names.Add("where");
}
if ((method.ShortName == "Join" || method.ShortName == "GroupJoin") && IsCorrectParametersNumberForQueryPatternMethod(method, 4))
{
names.Add("join");
}
if ((method.ShortName == "OrderBy" || method.ShortName == "OrderByDescending" || method.ShortName == "ThenBy" || method.ShortName == "ThenByDescending") && IsCorrectParametersNumberForQueryPatternMethod(method, 1))
{
names.Add("orderby");
}
if (method.ShortName == "GroupBy" && (IsCorrectParametersNumberForQueryPatternMethod(method, 1) || IsCorrectParametersNumberForQueryPatternMethod(method, 2)))
{
names.Add("group");
}
}
return names;
}
public List <Dictionary <string, IAssetValue> > ImportUnityEventData(UnityEventsElementContainer elementContainer, JetHashSet <string> allUnityEventNames)
{
var unityEvents = elementContainer.GetUnityEventDataFor(Location, allUnityEventNames);
var result = new List <Dictionary <string, IAssetValue> >();
foreach (var unityEventData in unityEvents)
{
for (int i = 0; i < unityEventData.Calls.Count; i++)
{
var dictionary = unityEventData.Calls[i].ToDictionary();
if (i < result.Count)
{
AssetUtils.Import(result[i], dictionary);
}
else
{
Assertion.Assert(result.Count == i, "result.Count == i");
result.Add(dictionary);
}
}
}
return(result);
}
private void ProcessDirective([NotNull] IT4Directive directive)
{
IT4Token nameToken = directive.GetNameToken();
if (nameToken == null)
return;
DirectiveInfo directiveInfo = _directiveInfoManager.GetDirectiveByName(nameToken.GetText());
if (directiveInfo == null)
return;
// Notify of missing required attributes.
IEnumerable<string> attributeNames = directive.GetAttributes().SelectNotNull(attr => attr.GetName());
var hashSet = new JetHashSet<string>(attributeNames, StringComparer.OrdinalIgnoreCase);
foreach (DirectiveAttributeInfo attributeInfo in directiveInfo.SupportedAttributes) {
if (attributeInfo.IsRequired && !hashSet.Contains(attributeInfo.Name)) {
AddHighlighting(new HighlightingInfo(nameToken.GetHighlightingRange(),
new MissingRequiredAttributeHighlighting(nameToken, attributeInfo.Name)));
}
}
// Assembly attributes in preprocessed templates are useless.
if (directiveInfo == _directiveInfoManager.Assembly && DaemonProcess.SourceFile.ToProjectFile().IsPreprocessedT4Template()) {
AddHighlighting(new HighlightingInfo(directive.GetHighlightingRange(), new IgnoredAssemblyDirectiveHighlighting(directive)));
}
}
private void SetInterestingReferences(params string[] names)
{
acceptableReferenceNames = new JetHashSet <string>(names);
}
private static void CheckMethodGroup(
[NotNull] IReferenceExpression methodReference,
[NotNull] IMethod method, [NotNull] IHighlightingConsumer consumer)
{
string message = null;
var methodType = method.GetContainingType();
if (methodType is IInterface)
{
message = string.Format("from interface '{0}' method", methodType.ShortName);
consumer.AddHighlighting(
new SlowDelegateCreationHighlighting(methodReference, message),
methodReference.GetExpressionRange());
return;
}
// there is not lags if method is instance method
if (!method.IsStatic &&
methodReference.QualifierExpression != null &&
methodReference.QualifierExpression.IsClassifiedAsVariable)
{
return;
}
var substitution = methodReference.Reference.Resolve().Result.Substitution;
var typeParameters = new JetHashSet <ITypeParameter>();
// collect all the type parameters from the method reference
if (!substitution.IsEmpty())
{
foreach (var typeParameter in substitution.Domain)
{
var substitutionType = substitution.Apply(typeParameter);
var targs = TypeParametersCollectingVisitor.Collect(substitutionType);
typeParameters.UnionWith(targs);
}
}
// get the delegate creation owner type, if member is not static
var delegateCreationMember = methodReference.GetContainingTypeMemberDeclaration();
if (delegateCreationMember == null || delegateCreationMember.DeclaredElement == null)
{
return;
}
ITypeElement delegateCreationOwnerType = null;
if (!delegateCreationMember.DeclaredElement.IsStatic)
{
delegateCreationOwnerType = delegateCreationMember.DeclaredElement.GetContainingType();
}
// look for implicit qualification with the type parameters
ITypeElement lastType = null;
for (var qualifier = methodReference; qualifier != null;
qualifier = qualifier.QualifierExpression as IReferenceExpression)
{
if (qualifier.IsClassifiedAsVariable)
{
lastType = null;
break;
}
var resolveResult = qualifier.Reference.Resolve();
lastType = resolveResult.DeclaredElement as ITypeElement;
}
if (lastType != null)
{
for (var hidden = lastType.GetContainingType(); hidden != null; hidden = hidden.GetContainingType())
{
if (hidden.TypeParameters.Count > 0)
{
foreach (var typeParameter in hidden.TypeParameters)
{
typeParameters.Add(typeParameter);
}
}
}
}
foreach (var parameter in typeParameters)
{
if (parameter.IsValueType)
{
continue;
}
if (delegateCreationOwnerType != null &&
delegateCreationOwnerType.TypeParameters.Contains(parameter))
{
continue;
}
if (message == null)
{
message = "method group parametrized with type parameter ";
}
if (parameter.OwnerType != null)
{
message += string.Format("'{0}' of type '{1}'", parameter.ShortName, parameter.OwnerType.ShortName);
}
else if (parameter.OwnerMethod != null)
{
message += string.Format("'{0}' of method '{1}'", parameter.ShortName, parameter.OwnerMethod.ShortName);
}
}
if (message != null)
{
consumer.AddHighlighting(
new SlowDelegateCreationHighlighting(methodReference, message),
methodReference.GetExpressionRange());
}
}
private bool IsOverridingTag(string name)
{
// This is horrible. We can't override existing tags and attributes, but we calling the
// other providers dynamically causes serious perf issues. We'll just make do with
// caching the standard HTML attributes and hope for the best. We also can't do this
// in the constructor, or we get a nasty circular instantiation issue. I'll file a YT
// ticket to handle this better in a future version.
if (allTags == null)
{
lock (lockObject)
{
if (allTags == null)
{
allTags = standardProvider.GetAllTagsSymbolTable().Names().ToHashSet(IdentityFunc<string>.Instance, StringComparer.InvariantCultureIgnoreCase);
}
}
}
return allTags.Contains(name);
}
private void SetInterestingReferences(params string[] names)
{
acceptableReferenceNames = new JetHashSet<string>(names);
}
private void ProcessDirective([NotNull] IT4Directive directive)
{
IT4Token nameToken = directive.GetNameToken();
if (nameToken == null)
return;
DirectiveInfo directiveInfo = _directiveInfoManager.GetDirectiveByName(nameToken.GetText());
if (directiveInfo == null)
return;
IEnumerable<string> attributeNames = directive.GetAttributes().SelectNotNull(attr => attr.GetName());
var hashSet = new JetHashSet<string>(attributeNames, StringComparer.OrdinalIgnoreCase);
foreach (DirectiveAttributeInfo attributeInfo in directiveInfo.SupportedAttributes) {
if (attributeInfo.IsRequired && !hashSet.Contains(attributeInfo.Name)) {
AddHighlighting(new HighlightingInfo(nameToken.GetHighlightingRange(),
new MissingRequiredAttributeHighlighting(nameToken, attributeInfo.Name)));
}
}
}
public ProjectSettingsCacheItem(ProjectSettingsSceneData sceneData = null,
JetHashSet <string> inputs = null, JetHashSet <string> tags = null, JetHashSet <string> layers = null)
{
Scenes = sceneData ?? new ProjectSettingsSceneData();
Inputs = inputs ?? new JetHashSet <string>();
Tags = tags ?? new JetHashSet <string>();
Layers = layers ?? new JetHashSet <string>();
}
private static void ReportClosureAllocations(
[NotNull] ITreeNode topDeclaration, [CanBeNull] IFunction thisElement, [CanBeNull] ILocalScope topScope,
[NotNull] ClosureInspector inspector, [NotNull] IHighlightingConsumer consumer)
{
var scopesMap = new Dictionary <IDeclaredElement, ILocalScope>();
var captureScopes = new Dictionary <ILocalScope, JetHashSet <IDeclaredElement> >();
// group captures by their scope, report non-cached delegates
foreach (var closure in inspector.Closures)
{
foreach (var capture in closure.Value)
{
ILocalScope scope = null;
if (capture is IFunction)
{
scope = topScope; // 'this' capture
}
else
{
var declarations = capture.GetDeclarations();
if (declarations.Count == 0) // accessors 'value' parameter
{
var accessor = thisElement as IAccessor;
if (accessor != null && Equals(accessor.ValueVariable, capture))
{
scope = topScope;
}
}
else
{
foreach (var declaration in declarations)
{
if (declaration is IRegularParameterDeclaration)
{
scope = topScope;
}
else
{
scope = declaration.GetContainingNode <ILocalScope>();
}
break;
}
}
}
if (scope == null)
{
continue;
}
JetHashSet <IDeclaredElement> captures;
if (!captureScopes.TryGetValue(scope, out captures))
{
captureScopes[scope] = captures = new JetHashSet <IDeclaredElement>();
}
captures.Add(capture);
scopesMap[capture] = scope;
}
{
var highlightingRange = GetClosureRange(closure.Key);
if (highlightingRange.IsValid())
{
if (IsExpressionLambda(closure.Key))
{
consumer.AddHighlighting(
new ObjectAllocationHighlighting(closure.Key, "expression tree construction"),
highlightingRange);
}
else
{
consumer.AddHighlighting(
new DelegateAllocationHighlighting(closure.Key, "capture of " + FormatClosureDescription(closure.Value)),
highlightingRange);
}
}
}
}
// highlight first captured entity per every scope
foreach (var scopeToCaptures in captureScopes)
{
var firstOffset = TreeOffset.MaxValue;
IDeclaredElement firstCapture = null;
foreach (var capture in scopeToCaptures.Value)
{
if (capture is IFunction)
{
continue;
}
var offset = GetCaptureStartOffset(capture);
if (offset < firstOffset)
{
firstOffset = offset;
firstCapture = capture;
}
}
var scopeClosure = FormatClosureDescription(scopeToCaptures.Value);
// collect outer captures
JetHashSet <IDeclaredElement> outerCaptures = null;
foreach (var closureToCaptures in inspector.Closures)
{
if (!scopeToCaptures.Key.Contains(closureToCaptures.Key))
{
continue;
}
foreach (var capture in closureToCaptures.Value)
{
ILocalScope scope;
if (!scopesMap.TryGetValue(capture, out scope))
{
continue;
}
if (scopeToCaptures.Key.Contains(scope))
{
continue;
}
outerCaptures = outerCaptures ?? new JetHashSet <IDeclaredElement>();
outerCaptures.Add(capture);
}
}
if (outerCaptures != null)
{
scopeClosure += string.Format(" + (outer closure of {0})", FormatClosureDescription(outerCaptures));
}
if (firstCapture != null)
{
DocumentRange highlightingRange;
var anchor = GetCaptureHighlightingRange(
topDeclaration, thisElement, firstCapture, out highlightingRange);
if (anchor != null && highlightingRange.IsValid())
{
consumer.AddHighlighting(
new ClosureAllocationHighlighting(anchor, scopeClosure),
highlightingRange);
}
}
}
}
// Возвращает множество существующих статусов для каждой переменной, определенной хотя бы в одном прердыдущей элементе.
// Если хотя бы один предыдущий элемент еще не посещался, то множество статусов для всех переменных будет содержать
// еще и статус Unknown.
// previousElems должен содержать null для элементов, у которых нет еще СontrolFlowElementData или которые не посещались.
private IDictionary<IVariableDeclaration, JetHashSet<VariableDisposeStatus>> GetPreviousElemsStatusSetsList(ICollection<ControlFlowElementData> previousElems)
{
var previousWithoutNotVisitedElements = previousElems.Where(e => e != null && e.IsVisited()).ToList();
var result = new Dictionary<IVariableDeclaration, JetHashSet<VariableDisposeStatus>>();
foreach (var status in previousWithoutNotVisitedElements.SelectMany(data => data.Status))
{
JetHashSet<VariableDisposeStatus> statusSet;
var hasValue = result.TryGetValue(status.Key, out statusSet);
if (hasValue)
statusSet.Add(status.Value);
else
{
statusSet = new JetHashSet<VariableDisposeStatus> {status.Value};
result[status.Key] = statusSet;
}
}
var hasNotVisitedElements = previousElems.Count != previousWithoutNotVisitedElements.Count;
if (hasNotVisitedElements)
result.ForEach(kvp => kvp.Value.Add(VariableDisposeStatus.Unknown));
return result;
}
public UnityEditorProtocol(Lifetime lifetime, ILogger logger, UnityHost host,
IScheduler dispatcher, IShellLocks locks, ISolution solution,
ISettingsStore settingsStore, JetBrains.Application.ActivityTrackingNew.UsageStatistics usageStatistics,
UnitySolutionTracker unitySolutionTracker, IThreading threading,
UnityVersion unityVersion, NotificationsModel notificationsModel,
IHostProductInfo hostProductInfo)
{
myPluginInstallations = new JetHashSet <FileSystemPath>();
myComponentLifetime = lifetime;
myLogger = logger;
myDispatcher = dispatcher;
myLocks = locks;
mySolution = solution;
myUsageStatistics = usageStatistics;
myThreading = threading;
myUnityVersion = unityVersion;
myNotificationsModel = notificationsModel;
myHostProductInfo = hostProductInfo;
myHost = host;
myBoundSettingsStore = settingsStore.BindToContextLive(lifetime, ContextRange.Smart(solution.ToDataContext()));
mySessionLifetimes = new SequentialLifetimes(lifetime);
if (solution.GetData(ProjectModelExtensions.ProtocolSolutionKey) == null)
{
return;
}
unitySolutionTracker.IsUnityProject.View(lifetime, (lf, args) =>
{
if (!args)
{
return;
}
var solFolder = mySolution.SolutionDirectory;
AdviseModelData(lifetime);
// todo: consider non-Unity Solution with Unity-generated projects
var protocolInstancePath = solFolder.Combine("Library/ProtocolInstance.json");
protocolInstancePath.Directory.CreateDirectory();
var watcher = new FileSystemWatcher();
watcher.Path = protocolInstancePath.Directory.FullPath;
watcher.NotifyFilter = NotifyFilters.LastWrite; //Watch for changes in LastWrite times
watcher.Filter = protocolInstancePath.Name;
// Add event handlers.
watcher.Changed += OnChanged;
watcher.Created += OnChanged;
lf.Bracket(() => { }, () =>
{
watcher.Dispose();
});
watcher.EnableRaisingEvents = true; // Begin watching.
// connect on start of Rider
CreateProtocols(protocolInstancePath);
});
}
private JetHashSet<VariableDisposeStatus> GetPreviousElemsThisStatusSet(
IEnumerable<ControlFlowElementData> previousElems)
{
var result = new JetHashSet<VariableDisposeStatus>();
foreach (var previousElementData in previousElems)
{
if (previousElementData == null || !previousElementData.IsVisited())
result.Add(VariableDisposeStatus.Unknown);
else
{
if (previousElementData.ThisStatus == null)
return null;
result.Add(previousElementData.ThisStatus.Value);
}
}
return result;
}
public TextOccurencesCollector(JetHashSet <string> texts, IFindResultConsumer <TResult> consumer)
{
myTexts = texts;
myConsumer = consumer;
}
// На основе множества статусов вычисляет один.
// (Для группы равноправных элементов, например, всех предыдущих элементов)
private VariableDisposeStatus UniteStatus(JetHashSet<VariableDisposeStatus> statusSet, bool hasCrossroads)
{
var disposedAndInvocationSet = new List<VariableDisposeStatus>
{
VariableDisposeStatus.Disposed,
VariableDisposeStatus.DependsOnInvocation
};
if (statusSet.IsSupersetOf(disposedAndInvocationSet))
return VariableDisposeStatus.Disposed;
if (statusSet.Contains(VariableDisposeStatus.DependsOnInvocation))
return VariableDisposeStatus.DependsOnInvocation;
var bothSet = new List<VariableDisposeStatus>
{
VariableDisposeStatus.Disposed,
VariableDisposeStatus.NotDisposed
};
if (statusSet.Contains(VariableDisposeStatus.Both) || statusSet.IsSupersetOf(bothSet))
return VariableDisposeStatus.Both;
if (!hasCrossroads)
{
if (statusSet.Contains(VariableDisposeStatus.Disposed))
return VariableDisposeStatus.Disposed;
if (statusSet.Contains(VariableDisposeStatus.NotDisposed))
return VariableDisposeStatus.NotDisposed;
Assertion.Fail("Unknown status");
return VariableDisposeStatus.Unknown;
}
if (statusSet.Contains(VariableDisposeStatus.Unknown))
return VariableDisposeStatus.Unknown;
if (statusSet.Contains(VariableDisposeStatus.Disposed))
return VariableDisposeStatus.Disposed;
return VariableDisposeStatus.NotDisposed;
}
public CgSyntaxHighlightingStage(CgSupportSettings cgSupportSettings)
{
myCgSupportSettings = cgSupportSettings;
mySemantics = CreateSemanticsSet();
}
public void SetCategories(JetHashSet <string> categories)
{
Categories = UnitTestElementCategory.Create(categories);
}
