public FSharpReferenceSearchProcessor(ITreeNode treeNode, bool findCandidates,
IFindResultConsumer <TResult> resultConsumer, IDeclaredElementsSet elements, IList <FSharpSymbol> fSharpSymbols,
ICollection <string> referenceNames) : base(treeNode, findCandidates, resultConsumer, elements, referenceNames,
referenceNames)
{
myFSharpSymbols = fSharpSymbols;
}
public Processor(
ITreeNode treeNode, bool findCandidates, IFindResultConsumer <TResult> resultConsumer,
IDeclaredElementsSet elements, ICollection <string> referenceNames
)
: base(treeNode, findCandidates, resultConsumer, elements, referenceNames, referenceNames)
{
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
var processor = new TextOccurencesCollector <TResult>(myTexts, consumer);
element.ProcessDescendants(processor);
return(false);
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
var result = new FSharpReferenceSearchProcessor <TResult>(element, myFindCandidates, consumer, myElements,
myFSharpSymbols, myElementNames).Run();
return(result == FindExecution.Stop);
}
// Note that some searchers (such as ReferenceSearchProcessorBase) will filter by word index before calling this.
// Words come from IDomainSpecificSearcherFactory.GetAllPossibleWordsInFile
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
if (sourceFile.GetPrimaryPsiFile() is IYamlFile yamlFile)
{
return(ProcessElement(yamlFile, consumer));
}
return(false);
}
public ReferenceSearchSourceFileProcessorWorkaround(ITreeNode treeNode, bool findCandidates,
IFindResultConsumer <TResult> resultConsumer, IDeclaredElementsSet elements,
ICollection <string> wordsInText, ICollection <string> referenceNames)
: base(treeNode, wordsInText, referenceNames, elements)
{
myFindCandidates = findCandidates;
myResultConsumer = resultConsumer;
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
Assertion.AssertNotNull(element, "element != null");
var result = new ReferenceSearchSourceFileProcessor <TResult>(element, myFindCandidates, consumer,
myElements, myElementNames, myElementNames).Run();
return(result == FindExecution.Stop);
}
private void DoSearch(IStructuralPatternHolder pattern, IFindResultConsumer <IStructuralMatchResult> consumer, ISearchDomain searchDomain)
{
var searcher = new StructuralSearcher(documentManager, pattern.Language, pattern.Matcher);
var searchDomainSearcher = new StructuralSearchDomainSearcher <IStructuralMatchResult>(
searchDomain, searcher, consumer, NullProgressIndicator.Instance, true);
searchDomainSearcher.Run();
}
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
if (!(sourceFile.GetPrimaryPsiFile() is ShaderLabFile shaderLabFile))
{
return(false);
}
return(ProcessElement(shaderLabFile, consumer));
}
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
if (myWordsInText.Any(word => myWordIndex.CanContainWord(sourceFile, word)))
{
return(sourceFile.GetPsiFiles <DslLanguage>().Any(file => ProcessElement(file, consumer)));
}
return(false);
}
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
if (!myDeferredCacheController.CompletedOnce.Value)
{
return(false);
}
foreach (var element in myElements)
{
if (element is IMethod || element is IProperty)
{
var usages = myAssetMethodsElementContainer.GetAssetUsagesFor(sourceFile, element);
foreach (var assetMethodData in usages)
{
var hierarchyElement = myAssetDocumentHierarchyElementContainer.GetHierarchyElement(assetMethodData.Location, false);
if (hierarchyElement != null)
{
consumer.Accept(new UnityMethodsFindResult(sourceFile, element, assetMethodData, hierarchyElement));
}
}
}
if (element is ITypeElement typeElement)
{
var usages = myAssetUsagesElementContainer.GetAssetUsagesFor(sourceFile, typeElement);
foreach (var assetUsage in usages)
{
var hierarchyElement = myAssetDocumentHierarchyElementContainer.GetHierarchyElement(assetUsage.Location, false);
if (hierarchyElement == null)
{
continue;
}
consumer.Accept(new UnityScriptsFindResults(sourceFile, element, assetUsage, hierarchyElement));
}
}
if (element is IField field)
{
var usages = myAssetInspectorValuesContainer.GetAssetUsagesFor(sourceFile, field);
foreach (var assetUsage in usages)
{
var hierarchyElement = myAssetDocumentHierarchyElementContainer.GetHierarchyElement(assetUsage.Location, false);
if (hierarchyElement == null)
{
continue;
}
consumer.Accept(new UnityInspectorFindResults(sourceFile, element, assetUsage, hierarchyElement));
}
}
}
return(false);
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
var sf = element.GetSourceFile();
if (sf != null)
{
ProcessProjectItem(sf, consumer);
}
return(false);
}
private void DoSearch(IStructuralMatcher matcher, IFindResultConsumer<IStructuralMatchResult> consumer, ISearchDomain searchDomain)
{
// todo add support for VB (eventually)
var searcher = new StructuralSearcher(documentManager, CSharpLanguage.Instance, matcher);
var searchDomainSearcher = new StructuralSearchDomainSearcher<IStructuralMatchResult>(
searchDomain, searcher, consumer, NullProgressIndicator.Instance, true);
//NarrowSearchDomain(matcher.Words, matcher.GetExtendedWords(solution), searchDomain, searchDomainFactory),
//searcher, consumer, NullProgressIndicator.Instance, true);
searchDomainSearcher.Run();
}
private void DoSearch(IStructuralMatcher matcher, IFindResultConsumer <IStructuralMatchResult> consumer, ISearchDomain searchDomain)
{
// todo add support for VB (eventually)
var searcher = new StructuralSearcher(documentManager, CSharpLanguage.Instance, matcher);
var searchDomainSearcher = new StructuralSearchDomainSearcher <IStructuralMatchResult>(
searchDomain, searcher, consumer, NullProgressIndicator.Instance, true);
//NarrowSearchDomain(matcher.Words, matcher.GetExtendedWords(solution), searchDomain, searchDomainFactory),
//searcher, consumer, NullProgressIndicator.Instance, true);
searchDomainSearcher.Run();
}
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
if (myElements.All(element => !CanContainReferencesTo(sourceFile, element)))
{
return(false);
}
IFile psiFile = sourceFile.GetPsiFile <PsiLanguage>(new DocumentRange(sourceFile.Document, 0));
return(psiFile != null && ProcessElement(psiFile, consumer));
}
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
if (!this.CanContainReferencesTo(sourceFile))
{
return(false);
}
IFile psiFile = sourceFile.GetPsiFile <NTriplesLanguage>(new DocumentRange(sourceFile.Document, 0));
return(psiFile != null && this.ProcessElement(psiFile, consumer));
}
private void AddScriptUsages <TResult>([NotNull] IPsiSourceFile sourceFile,
[NotNull] IFindResultConsumer <TResult> consumer,
[NotNull] ITypeElement typeElement,
[NotNull] IDeclaredElement element)
{
foreach (var scriptUsagesContainer in myScriptsUsagesElementContainers)
{
var scriptUsages = scriptUsagesContainer.GetScriptUsagesFor(sourceFile, typeElement);
foreach (var scriptUsage in scriptUsages)
{
consumer.Accept(new UnityScriptsFindResults(sourceFile, element, scriptUsage, scriptUsage.Location));
}
}
}
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
if (!myDeferredCacheController.CompletedOnce.Value)
{
return(false);
}
foreach (var element in myElements)
{
if (element is IMethod || element is IProperty)
{
var usages = myUnityEventsElementContainer.GetAssetUsagesFor(sourceFile, element);
foreach (var findResult in usages)
{
consumer.Accept(findResult);
}
}
if (element is ITypeElement typeElement)
{
var usages = myAssetScriptUsagesElementContainer.GetAssetUsagesFor(sourceFile, typeElement);
foreach (var assetUsage in usages)
{
consumer.Accept(new UnityScriptsFindResults(sourceFile, element, assetUsage, assetUsage.Location));
}
}
if (element is IField field)
{
if (UnityApi.IsDescendantOfUnityEvent(field.Type.GetTypeElement()))
{
foreach (var findResult in myUnityEventsElementContainer.GetMethodsForUnityEvent(sourceFile, field))
{
consumer.Accept(findResult);
}
}
else
{
var usages = myAssetInspectorValuesContainer.GetAssetUsagesFor(sourceFile, field);
foreach (var findResult in usages)
{
consumer.Accept(findResult);
}
}
}
}
return(false);
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
Assertion.Assert(element != null, "The condition (element != null) is false.");
var names = new JetHashSet <string>(this.myNames);
FindExecution result;
if (this.mySearchForLateBound)
{
result =
new LateBoundReferenceSourceFileProcessor <TResult>(
element,
consumer,
this.myElements,
this.myHasUnnamedElement
? null
: names,
names).Run();
}
else
{
var psiSourceFile = element.GetSourceFile();
foreach (var myElement in this.myElements)
{
var declarations = myElement.GetDeclarationsIn(psiSourceFile);
foreach (var declaration in declarations)
{
var refs = declaration.GetFirstClassReferences();
foreach (var r in refs)
{
consumer.Accept(new FindResultReference(r, declaration.DeclaredElement));
}
}
}
result =
new ReferenceSearchSourceFileProcessor <TResult>(
element,
true,
consumer,
this.myElements,
this.myHasUnnamedElement
? null
: names,
names).Run();
}
return(result == FindExecution.Stop);
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
Assertion.Assert(element != null, "The condition (element != null) is false.");
var names = new JetHashSet <string>(myNames);
FindExecution result;
if (mySearchForLateBound)
{
result = new LateBoundReferenceSourceFileProcessor <TResult>(element, consumer, myElements, myHasUnnamedElement ? null : names, names).Run();
}
else
{
result = new ReferenceSearchSourceFileProcessor <TResult>(element, true, consumer, myElements, myHasUnnamedElement ? null : names, names).Run();
}
return(result == FindExecution.Stop);
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
if (!element.Language.Is <GherkinLanguage>())
{
return(false);
}
var containingFile = element.GetContainingFile();
if (containingFile == null)
{
return(false);
}
var projectFile = containingFile.GetSourceFile().ToProjectFile();
if (projectFile == null || !projectFile.IsValid())
{
return(false);
}
foreach (var declaredElement in _declaredElements)
{
if (!(declaredElement is IMethod method))
{
continue;
}
foreach (var gherkinStep in element.GetChildrenInSubtrees <GherkinStep>())
{
var reference = gherkinStep.GetStepReference();
var resolveResultWithInfo = reference.Resolve();
if (resolveResultWithInfo.ResolveErrorType == ResolveErrorType.OK)
{
foreach (var declarationMethod in resolveResultWithInfo.Result.Elements <IMethod>())
{
if (declarationMethod.Element.Equals(method) && consumer.Accept(new FindResultReference(reference)) == FindExecution.Stop)
{
return(true);
}
}
}
}
}
return(false);
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
Assertion.Assert(element != null, "The condition (element != null) is false.");
var names = new JetHashSet <string>(myNames, StringComparer.OrdinalIgnoreCase);
NamedThingsSearchSourceFileProcessor processor;
if (mySearchForLateBound)
{
processor = new LateBoundReferenceSourceFileProcessor <TResult>(element, consumer, myElements, myWordsInText, names);
}
else
{
processor = new ReferenceSearchSourceFileProcessor <TResult>(element, myFindCandidates, consumer, myElements, myWordsInText, names);
}
return(processor.Run() == FindExecution.Stop);
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
Assertion.AssertNotNull(element, "element != null");
// wordsInText is used to create string searchers, which are used to see if chameleon subtree should be opened.
// If this is null or empty, then all references are processed, without skipping chameleons. References are cached
// in both cases.
// referenceNames is used to create a reference name container which is used to optimise things. It's passed to
// the reference provider's HasReferences to get a false or "maybe" based on name. It's then used (along with
// PreFilterReference) to filter references before they're resolved, based on GetName/GetAllNames.
// Normally, wordsInText will match referenceNames, as the reference's GetName will return a string that is also
// in the text. One example of a reference with a different name is a constructor initialiser, where the name is
// .ctor, but would appear in text as this or base
var wordsInText = ElementNames;
var referenceNames = ElementNames;
var result = new ReferenceSearchSourceFileProcessorWorkaround <TResult>(element, myFindCandidates, consumer, myElements,
wordsInText, referenceNames).Run();
return(result == FindExecution.Stop);
}
public bool ProcessElement <TResult>(ITreeNode element, IFindResultConsumer <TResult> consumer)
{
var referenceNames = new HashSet <string>();
var references = _referenceFactory.GetReferences(element, ReferenceCollection.Empty);
foreach (var reference in references)
{
var resolve = reference.Resolve();
if (resolve.Info.ResolveErrorType == ResolveErrorType.OK && _elements.Contains(resolve.Result.DeclaredElement))
{
referenceNames.Add(reference.GetName());
}
}
var result = new Processor <TResult>(element, _findCandidate, consumer, _elements, referenceNames).Run();
return(result == FindExecution.Stop);
}
private void FetchTextOccurences([NotNull] ITreeNode textToken, IFindResultConsumer <TResult> consumer)
{
var file = textToken.GetContainingFile();
if (file != null)
{
var text = textToken.GetText();
var textLength = text.Length;
foreach (string name in myTexts)
{
var nameLength = name.Length;
for (int start = 0; start < textLength;)
{
int pos = text.IndexOf(name, start, StringComparison.Ordinal);
if (pos < 0)
{
break;
}
var range = textToken.GetDocumentRange();
if (range.IsValid())
{
var textRange = new TextRange(range.TextRange.StartOffset + pos, range.TextRange.StartOffset + pos + nameLength);
var nameDocumentRange = new DocumentRange(range.Document, textRange);
var translatedRange = file.Translate(nameDocumentRange);
if (!DeclarationExists(textToken, translatedRange) && !ReferenceExists(file, translatedRange))
{
consumer.Accept(new FindResultText(file.GetSourceFile(), nameDocumentRange));
}
}
start = pos + nameLength;
}
}
}
}
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
try
{
if (!myDeferredCacheController.CompletedOnce.Value)
{
return(false);
}
foreach (var element in myElements)
{
if (element is IMethod || element is IProperty)
{
var animationEventUsages = myAnimationEventUsagesContainer.GetEventUsagesFor(sourceFile, element);
foreach (var usage in animationEventUsages)
{
var occurence = new UnityAnimationEventFindResults(sourceFile, element, usage, usage.Location);
consumer.Accept(occurence);
}
var usages = myUnityEventsElementContainer.GetAssetUsagesFor(sourceFile, element);
foreach (var findResult in usages)
{
consumer.Accept(findResult);
}
}
if (element is ITypeElement typeElement)
{
AddScriptUsages(sourceFile, consumer, typeElement, element);
}
if (element is IField field)
{
if (field.Type.GetTypeElement().DerivesFromUnityEvent())
{
foreach (var findResult in myUnityEventsElementContainer.GetMethodsForUnityEvent(sourceFile, field))
{
consumer.Accept(findResult);
}
}
else
{
var usages = myAssetInspectorValuesContainer.GetAssetUsagesFor(sourceFile, field);
foreach (var findResult in usages)
{
consumer.Accept(findResult);
}
}
}
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception e)
{
ourLogger.Error(e, $"An error occurred while searching assets in: {sourceFile.GetPersistentIdForLogging()}");
}
return(false);
}
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
return(sourceFile.LanguageType.Is <GherkinProjectFileType>() && sourceFile.GetPsiFiles <GherkinLanguage>().Any(file => ProcessElement(file, consumer)));
}
public TextOccurencesCollector(JetHashSet <string> texts, IFindResultConsumer <TResult> consumer)
{
myTexts = texts;
myConsumer = consumer;
}
public bool ProcessProjectItem <TResult>(IPsiSourceFile sourceFile, IFindResultConsumer <TResult> consumer)
{
return(sourceFile.GetPsiFiles <DslLanguage>().Any(file => ProcessElement(file, consumer)));
}
