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))); }