public IEnumerable <RegistrationInfo> Analyze(IPsiSourceFile sourceFile) { ICSharpFile cSharpFile; #if SDK70 cSharpFile = sourceFile.GetTheOnlyPsiFile(CSharpLanguage.Instance) as ICSharpFile; #else cSharpFile = sourceFile.GetPsiFile(CSharpLanguage.Instance) as ICSharpFile; #endif if (cSharpFile == null) { return(EmptyList <RegistrationInfo> .InstanceList); } var usingStatements = cSharpFile.Imports .Where(directive => !directive.ImportedSymbolName.QualifiedName.StartsWith("System")) .Select(directive => directive.ImportedSymbolName.QualifiedName).ToList(); IContainerInfo matchingContainer = GetMatchingContainer(usingStatements); if (matchingContainer == null) { return(EmptyList <RegistrationInfo> .InstanceList); } ISearchDomain searchDomain = searchDomainFactory.CreateSearchDomain(sourceFile); return(ScanRegistrations(matchingContainer, searchDomain)); }
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)); }
protected override SearchDeclaredElementUsagesRequest CreateSearchRequest(IDataContext context, ICollection <DeclaredElementInstance> elements, ICollection <DeclaredElementInstance> initialTargets, ISearchDomain searchDomain) { return(RequestUtil.CreateRequest(context, elements, initialTargets)); }
public SearchGenericImplementationsRequest(DeclaredElementTypeUsageInfo declaredElement, ITypeElement originType, ISearchDomain searchDomain, IEnumerable<IDeclaredType> originTypeParams) : base(declaredElement, originType, searchDomain) { _originTypeParams = originTypeParams; }
public SearchGenericUsagesRequest(ICollection<DeclaredElementInstance> elements, ICollection<DeclaredElementInstance> initialTargets, ISearchDomain searchDomain, IEnumerable<IDeclaredType> originTypeParams) : base(elements, initialTargets, SearchPattern.FIND_USAGES, searchDomain) { _originTypeParams = originTypeParams; }
public void Execute(Action <DaemonStageResult> committer) { IPsiSourceFile sourceFile = DaemonProcess.SourceFile; IPsiServices psiServices = sourceFile.GetPsiServices(); ISymbolScope symbolScope = psiServices.Symbols.GetSymbolScope(LibrarySymbolScope.FULL, false, sourceFile.ResolveContext); ITypeElement typeElement = symbolScope.GetTypeElementByCLRName("TestStack.BDDfy.BDDfyExtensions"); if (typeElement == null) { return; } IEnumerable <IMethod> bddfyMethods = typeElement.Methods.Where(method => method.ShortName == "BDDfy" || method.ShortName == "LazyBDDfy"); ISearchDomain searchDomain = searchDomainFactory.CreateSearchDomain(sourceFile); IReference[] references = bddfyMethods.SelectMany(method => psiServices.Finder.FindReferences(method, searchDomain, NullProgressIndicator.Instance)).ToArray(); foreach (IReference reference in references) { var node = reference.GetTreeNode() as ICSharpTreeNode; if (node != null) { var classDeclaration = node.GetContainingTypeDeclaration() as IClassDeclaration; if (classDeclaration != null) { SetClassAndMembersUsed(classDeclaration); } } } }
public IEnumerable<IStructuralMatchResult> Search(IStructuralPatternHolder pattern, ISearchDomain searchDomain) { var results = new List<IStructuralMatchResult>(); var consumer = new FindResultConsumer<IStructuralMatchResult>(result => { var findResultStructural = result as FindResultStructural; if (findResultStructural != null && findResultStructural.DocumentRange.IsValid()) { return findResultStructural.MatchResult; } return null; }, match => { if (match != null) { results.Add(match); } return FindExecution.Continue; }); DoSearch(pattern.Matcher, consumer, searchDomain); return results; }
public WebSearch(ISearchDomain searchDomain, IKeywordExtractor keywordExtractor) { SearchDomain = searchDomain; KeywordExtractor = keywordExtractor; SearchSettings.MaxLinks = _maxLinks; SearchSettings.MaxParagraphs = _maxParagraphs; }
public SearchGenericUsagesRequest(ICollection <DeclaredElementInstance> elements, ICollection <DeclaredElementInstance> initialTargets, ISearchDomain searchDomain, IEnumerable <IDeclaredType> originTypeParams) : base(elements, initialTargets, SearchPattern.FIND_USAGES, searchDomain) { _originTypeParams = originTypeParams; }
public SearchGenericImplementationsRequest(DeclaredElementTypeUsageInfo declaredElement, ITypeElement originType, ISearchDomain searchDomain, IEnumerable <IDeclaredType> originTypeParams) : base(declaredElement, originType, searchDomain) { _originTypeParams = originTypeParams; }
static TestDomainData[] GenTest(IHeuristic heuristic, int numTasks = 100, int numSteps = Global.MAXSTEPS, bool writeCSV = true, bool computeCost = true) { TestDomainData[] data = new TestDomainData[numTasks]; string csvWritePath = string.Format(Global.ROOTPATH, Global.TESTTASKFN); CSVWriter csv = new CSVWriter(csvWritePath, ','); for (int i = 0; i < numTasks; i++) { DomainContainer domainContainer = new DomainContainer(heuristic, numSteps); ISearchDomain domain = domainContainer.Domain; IState initState = domain.Initial(); string initStateStr = string.Join(" ", initState.Arr); int cost = 0; long generated = 0; if (computeCost == true) { if (Global.DOMAINTYPE == typeof(BlocksWorld.BlocksWorld) && heuristic == null) { cost = PostBlocksWorld(initState, domain.Goal()); } else { IDAStar <ISearchDomain> planner = new IDAStar <ISearchDomain>(domain); List <IState> plan = planner.Search(initState); cost = (plan.Count - 1); generated = planner.Generated; } } data[i] = new TestDomainData(initState.Arr, cost, generated); csv.Add(initStateStr); csv.Add(cost.ToString()); csv.Add(generated.ToString()); csv.EndLine(); } if (writeCSV == true) { csv.Write(); } return(data); }
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 static ISearchDomain GetSearchDomain(IPsiModule module, IModuleReferenceResolveContext context) { IPsiServices psiServices = module.GetPsiServices(); ISearchDomain searchDomain = psiServices.SearchDomainFactory.CreateSearchDomain( module.GetPsiServices().Modules.GetModules() .Where(m => m.References(module, context) || module.References(m, context)) .Prepend(module)); return(searchDomain); }
public UnityEditorFindUsageResultCreator(Lifetime lifetime, ISolution solution, SearchDomainFactory searchDomainFactory, IShellLocks locks, UnitySceneDataLocalCache sceneDataCache, UnityHost unityHost, UnityExternalFilesModuleFactory externalFilesModuleFactory, [CanBeNull] RiderBackgroundTaskHost backgroundTaskHost = null) { myLifetime = lifetime; mySolution = solution; myLocks = locks; myUnitySceneDataLocalCache = sceneDataCache; myBackgroundTaskHost = backgroundTaskHost; myYamlSearchDomain = searchDomainFactory.CreateSearchDomain(externalFilesModuleFactory.PsiModule); myUnityHost = unityHost; mySolutionDirectoryPath = solution.SolutionDirectory; }
public IEnumerable <RegistrationInfo> Analyze([NotNull] IPsiSourceFile sourceFile) { IContainerInfo matchingContainer = GetMatchingContainer(sourceFile); if (matchingContainer == null) { return(EmptyList <RegistrationInfo> .InstanceList); } ISearchDomain searchDomain = searchDomainFactory.CreateSearchDomain(sourceFile); return(ScanRegistrations(matchingContainer, searchDomain)); }
public static OneToListMap <string, IClass> GetAvailableModules([NotNull] IPsiModule module, [NotNull] ISearchDomain searchDomain, IModuleReferenceResolveContext contex, bool includingIntermediateControllers = false, ITypeElement baseClass = null) { ITypeElement[] typeElements; ITypeElement nancyModuleInterface = GetNancyModuleInterface(module, contex); if (baseClass != null) { if (baseClass.IsDescendantOf(nancyModuleInterface)) { typeElements = new[] { baseClass }; } else { return(new OneToListMap <string, IClass>(0)); } } else { typeElements = new[] { nancyModuleInterface }; } var found = new List <IClass>(); foreach (ITypeElement typeElement in typeElements.WhereNotNull()) { module.GetPsiServices() .Finder.FindInheritors(typeElement, searchDomain, found.ConsumeDeclaredElements(), NullProgressIndicator.Instance); } IEnumerable <IClass> classes = found.Where(@class => @class.GetAccessRights() == AccessRights.PUBLIC); if (!includingIntermediateControllers) { classes = classes.Where(@class => [email protected] && @class.ShortName.EndsWith(ModuleClassSuffix, StringComparison.OrdinalIgnoreCase)); } return(new OneToListMap <string, IClass>( classes.GroupBy(GetControllerName, (name, enumerable) => new KeyValuePair <string, IList <IClass> >(name, enumerable.ToList())), StringComparer.OrdinalIgnoreCase)); }
public UnityEditorFindUsageResultCreator(Lifetime lifetime, ISolution solution, SearchDomainFactory searchDomainFactory, IShellLocks locks, AssetHierarchyProcessor assetHierarchyProcessor, UnityHost unityHost, UnityExternalFilesModuleFactory externalFilesModuleFactory, UnityEditorProtocol editorProtocol, IPersistentIndexManager persistentIndexManager, [CanBeNull] RiderBackgroundTaskHost backgroundTaskHost = null) { myLifetime = lifetime; mySolution = solution; myLocks = locks; myAssetHierarchyProcessor = assetHierarchyProcessor; myBackgroundTaskHost = backgroundTaskHost; myYamlSearchDomain = searchDomainFactory.CreateSearchDomain(externalFilesModuleFactory.PsiModule); myUnityHost = unityHost; myEditorProtocol = editorProtocol; myPersistentIndexManager = persistentIndexManager; mySolutionDirectoryPath = solution.SolutionDirectory; }
public DomainContainer(NNBaseHeuristic heuristic, double maxUncert, int maxSteps = 1000) { if (Global.DOMAINTYPE == typeof(SlidingPuzzle.SlidingPuzzle)) { domain = new SlidingPuzzle.SlidingPuzzle(heuristic, maxUncert, maxSteps); } else if (Global.DOMAINTYPE == typeof(PancakePuzzle.PancakePuzzle)) { domain = new PancakePuzzle.PancakePuzzle(heuristic, maxUncert, maxSteps); } else if (Global.DOMAINTYPE == typeof(BlocksWorld.BlocksWorld)) { domain = new BlocksWorld.BlocksWorld(heuristic, maxUncert, maxSteps); } else { throw new ArgumentOutOfRangeException(); } }
public DomainContainer(IHeuristic heuristic, int steps) { if (Global.DOMAINTYPE == typeof(SlidingPuzzle.SlidingPuzzle)) { domain = new SlidingPuzzle.SlidingPuzzle(heuristic, steps); } else if (Global.DOMAINTYPE == typeof(PancakePuzzle.PancakePuzzle)) { domain = new PancakePuzzle.PancakePuzzle(heuristic, steps); } else if (Global.DOMAINTYPE == typeof(BlocksWorld.BlocksWorld)) { domain = new BlocksWorld.BlocksWorld(heuristic, steps); } else { throw new ArgumentOutOfRangeException(); } }
public UnityEditorFindUsageResultCreator(Lifetime lifetime, ISolution solution, SearchDomainFactory searchDomainFactory, IShellLocks locks, AssetHierarchyProcessor assetHierarchyProcessor, BackendUnityHost backendUnityHost, FrontendBackendHost frontendBackendHost, UnityExternalFilesModuleFactory externalFilesModuleFactory, IPersistentIndexManager persistentIndexManager, [NotNull] AnimatorScriptUsagesElementContainer animatorContainer, [CanBeNull] RiderBackgroundTaskHost backgroundTaskHost = null) { myLifetime = lifetime; mySolution = solution; myLocks = locks; myAssetHierarchyProcessor = assetHierarchyProcessor; myBackendUnityHost = backendUnityHost; myBackgroundTaskHost = backgroundTaskHost; myYamlSearchDomain = searchDomainFactory.CreateSearchDomain(externalFilesModuleFactory.PsiModule); myFrontendBackendHost = frontendBackendHost; myAnimatorContainer = animatorContainer; myPersistentIndexManager = persistentIndexManager; mySolutionDirectoryPath = solution.SolutionDirectory; }
public IEnumerable <RegistrationInfo> Analyze(IEnumerable <IPsiSourceFile> sourceFiles) { ISearchDomain searchDomain = searchDomainFactory.CreateSearchDomain(sourceFiles); return(knownContainers.SelectMany(info => ScanRegistrations(info, searchDomain))); }
public ProductController(IProductDomain productDomain, ISearchDomain searchDomain) { ProductDomain = productDomain; SearchDomain = searchDomain; }
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(); }
/// <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 static void Train(int run, int iter, int numOutputSolve, bool genDomainFromUncert, int lengthInc, bool effRun) { string runType = GetRunType(numOutputSolve, genDomainFromUncert, lengthInc, effRun); string csvWritePath = string.Format(Global.RUNPATH, run, runType, Global.TRAINFN); int numHiddenSolve = 20; if (multHeuristic != null) { numHiddenSolve = 8; } int?numHiddenUncert = numHiddenSolve; if (genDomainFromUncert == false) { numHiddenUncert = null; } float dropout = 0F; if (multHeuristic == null && numOutputSolve > 1) { dropout = 0.025F; } NNBayesHeuristic heuristic = new NNBayesHeuristic(representationSolve, representationUncert, numHiddenSolve, numOutputSolve, numHiddenUncert, dropout, true); heuristic.ConfLevel = null; if (numOutputSolve > 1) { heuristic.ConfLevel = 0.01; } double incConfLevel = 0.05; double percSolvedThresh = 0.6; int numTasks = 10; int tMax; if (effRun == true) { tMax = 1000; } else if (multHeuristic == null) { tMax = 60000; } else { tMax = 5 * 60000; } CSVWriter csv = new CSVWriter(csvWritePath, ','); Stopwatch sw = new Stopwatch(); sw.Start(); int length = lengthInc; for (int n = 0; n < iter; n++) { List <List <IState> > plans = new List <List <IState> >(numTasks); int countSolved = 0; for (int i = 0; i < numTasks; i++) { heuristic.ClearCache(); DomainContainer domainContainer; if (genDomainFromUncert == true) { if (heuristic.IsTrained) { domainContainer = new DomainContainer(heuristic, Global.UNCERTTHRESH, Global.MAXSTEPS); } else { domainContainer = new DomainContainer(heuristic, 1); } } else { domainContainer = new DomainContainer(heuristic, length); } ISearchDomain domain = domainContainer.Domain; heuristic.ClearCache(); GC.Collect(); IDAStar <ISearchDomain> planner = new IDAStar <ISearchDomain>(domain); List <IState> plan = planner.Search(domain.Initial(), tMax); Console.WriteLine("expanded: " + planner.Expanded); Console.WriteLine("generated: " + planner.Generated); Console.WriteLine("elapsed: " + planner.SwopWatch.ElapsedMilliseconds); if (plan.Count > 0) { countSolved++; Console.WriteLine("solved solution length:" + plan.Count); plans.Add(plan); } csv.Add(n.ToString()); csv.Add(planner.SwopWatch.ElapsedMilliseconds.ToString()); csv.Add(planner.Expanded.ToString()); csv.Add(planner.Generated.ToString()); csv.Add(heuristic.ConfLevel == null ? "NULL" : heuristic.ConfLevel.ToString()); csv.Add(plan.Count.ToString()); csv.Add(domain.NumSteps.ToString()); csv.EndLine(); } string nnFileName = string.Format(Global.NNFN, n); string nnSavePath = string.Format(Global.RUNPATH, run, runType, nnFileName); heuristic.NNSolve.Save(nnSavePath, true); double percSolved = countSolved / (double)numTasks; if (percSolved < percSolvedThresh) { heuristic.UpdateBeta = false; if (heuristic.ConfLevel != null && heuristic.ConfLevel < 0.5) { heuristic.ConfLevel += incConfLevel; if (heuristic.ConfLevel > 0.5) { heuristic.ConfLevel = 0.5; } } } else { heuristic.UpdateBeta = true; } if (plans.Count > 0) { double avg = plans.Select(x => x.Count).Average(); double max = plans.Select(x => x.Count).Max(); double min = plans.Select(x => x.Count).Min(); Console.WriteLine("solved: " + plans.Count + " avg: " + avg + " max: " + max + " min: " + min); Console.WriteLine("current conf level: " + heuristic.ConfLevel == null ? "NULL" : heuristic.ConfLevel.ToString()); } long t = sw.ElapsedMilliseconds; length += lengthInc; csv.Add(t.ToString()); csv.EndLine(); csv.Write(); csv.Clear(); heuristic.Update(plans.ToArray()); } heuristic.Dispose(); }
private IEnumerable <RegistrationInfo> ScanRegistrations(IContainerInfo containerInfo, ISearchDomain searchDomain) { return(from pattern in containerInfo.RegistrationPatterns let matchResults = patternSearcher.Search(pattern, searchDomain) from matchResult in matchResults.Where(result => result.Matched) from registration in pattern.GetComponentRegistrations(matchResult.MatchedElement) select new RegistrationInfo(registration, containerInfo.ContainerDisplayName)); }
static int SolveTestData(IHeuristic heuristic, TestDomainData[] data, CSVWriter csvWriter, int?timeout) { Stopwatch sw = new Stopwatch(); sw.Start(); int countSolved = 0; for (int i = 0; i < data.Length; i++) { Console.WriteLine("iter: " + i.ToString()); if (timeout != null && sw.ElapsedMilliseconds > timeout) { break; } heuristic.ClearCache(); GC.Collect(); TestDomainData testDomainData = data[i]; DomainContainer domainContainer = new DomainContainer(heuristic, testDomainData.Init); ISearchDomain domain = domainContainer.Domain; IDAStar <ISearchDomain> planner = new IDAStar <ISearchDomain>(domain); List <IState> plan = planner.Search(domain.Initial(), timeout); testDomainData.SolvedCost = plan.Count - 1; testDomainData.SolvedExpanded = planner.Expanded; testDomainData.SolvedGenerated = planner.Generated; if (testDomainData.SolvedCost > 0) { csvWriter.Add(planner.Expanded.ToString()); csvWriter.Add(planner.Generated.ToString()); csvWriter.Add(testDomainData.OptimalCost.ToString()); csvWriter.Add(testDomainData.SolvedCost.ToString()); csvWriter.Add(planner.SwopWatch.ElapsedMilliseconds.ToString()); csvWriter.EndLine(); csvWriter.Write(); csvWriter.Clear(); countSolved++; } Console.WriteLine("cost: " + (plan.Count - 1).ToString()); Console.WriteLine("generated: " + planner.Generated); Console.WriteLine("elapsed: " + planner.SwopWatch.ElapsedMilliseconds); } return(countSolved); }
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 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 WebSearch(ISearchDomain searchDomain, IKeywordExtractor keywordExtractor, SearchSettingsType settings) : this(searchDomain, keywordExtractor) { SearchSettings = settings; }
/// <summary> /// Initializes a new instance of the <see cref="FindItemUsagesRequest" /> class. /// </summary> /// <param name="solution">The solution.</param> /// <param name="searchDomain">The search domain.</param> public FindItemUsagesRequest(ISolution solution, ISearchDomain searchDomain) : base(solution, searchDomain) { }
protected override SearchDeclaredElementUsagesRequest CreateSearchRequest(IDataContext context, ICollection<DeclaredElementInstance> elements, ICollection<DeclaredElementInstance> initialTargets, ISearchDomain searchDomain) { return RequestUtil.CreateRequest(context, elements, initialTargets); }
private IEnumerable<RegistrationInfo> ScanRegistrations(IContainerInfo containerInfo, ISearchDomain searchDomain) { return from pattern in containerInfo.RegistrationPatterns let matchResults = patternSearcher.Search(pattern, searchDomain) from matchResult in matchResults.Where(result => result.Matched) from registration in pattern.GetComponentRegistrations(matchResult.MatchedElement) select new RegistrationInfo(registration, containerInfo.ContainerDisplayName); }
public static string DetermineViewModelType(ITreeNode node, IType defaultType = null) { Func <IEnumerable <IType>, IType> typeChecker = types => types.FirstOrDefault( type => type != null && !type.IsUnknown && !type.IsObject() && !(type is IAnonymousType)); // first, try determine type of explicitly specified model IType modelType = typeChecker( RetrieveArgumentExpressions( (node.GetContainingNode <IArgument>(true) ?? node).GetContainingNode <IArgumentsOwner>(true), MvcKind.ModelType) .Select(pair => pair.First).Select(_ => _.Type())); // second, try determine type of implicitly specified model if (modelType == null) { IPsiServices psiServices = node.GetPsiServices(); ISolution solution = psiServices.Solution; var languageManager = solution.GetComponent <ILanguageManager>(); #if SDK80 IMvcElementsCache mvcElementsCache = MvcElementsCache.GetInstance(node.GetPsiModule(), node.GetResolveContext()); #else IMvcElementsCache mvcElementsCache = MvcElementsCache.GetInstance(node.GetPsiModule()); #endif List <IDeclaredElement> setters = new[] { mvcElementsCache.MvcViewDataDictionaryClass, mvcElementsCache.MvcTypedViewDataDictionaryClass } .WhereNotNull() .SelectMany(typeElement => typeElement.Properties) .Where( property => String.Equals(property.ShortName, "Model", property.CaseSensistiveName ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase)) .Select <IProperty, IDeclaredElement>(property => property.Setter) .ToList(); ISearchDomain searchDomain = solution.GetComponent <SearchDomainFactory>() .CreateSearchDomain(node.GetContainingNode <ITypeOwnerDeclaration>() ?? node); var references = new List <IReference>(); psiServices.Finder.Find(setters, searchDomain, references.ConsumeReferences(), SearchPattern.FIND_USAGES | SearchPattern.FIND_RELATED_ELEMENTS, NullProgressIndicator.Instance); modelType = typeChecker(references .Select(reference => reference.GetTreeNode()) .OfType <IExpression>() .Select( expression => languageManager.GetService <IMvcLanguageHelper>(expression.Language) .GetAssigmentType(expression))) ?? defaultType; // default type, fallback } if (modelType == null) { return(null); } return(modelType.GetLongPresentableName(node.Language)); }
public IEnumerable <RegistrationInfo> Analyze() { ISearchDomain searchDomain = searchDomainFactory.CreateSearchDomain(solution, false); return(knownContainers.SelectMany(info => ScanRegistrations(info, searchDomain))); }
public PubSearchController(ISearchDomain searchDomain, ICacheManager Cache) : base(Cache) { SearchDomain = searchDomain; }
public IEnumerable <IStructuralMatchResult> Search(IStructuralPatternHolder pattern, ISearchDomain searchDomain) { var results = new List <IStructuralMatchResult>(); var consumer = new FindResultConsumer <IStructuralMatchResult>(result => { var findResultStructural = result as FindResultStructural; if (findResultStructural != null && findResultStructural.DocumentRange.IsValid()) { return(findResultStructural.MatchResult); } return(null); }, match => { if (match != null) { results.Add(match); } return(FindExecution.Continue); }); DoSearch(pattern.Matcher, consumer, searchDomain); return(results); }