protected override Task <ImmutableArray <Document> > DetermineDocumentsToSearchAsync( IMethodSymbol symbol, Project project, IImmutableSet <Document>?documents, FindReferencesSearchOptions options, CancellationToken cancellationToken) { return(FindDocumentsAsync(project, documents, async(d, c) => { var index = await SyntaxTreeIndex.GetIndexAsync(d, c).ConfigureAwait(false); if (index.ContainsBaseConstructorInitializer) { return true; } if (index.ProbablyContainsIdentifier(symbol.ContainingType.Name)) { if (index.ContainsThisConstructorInitializer) { return true; } else if (project.Language == LanguageNames.VisualBasic && index.ProbablyContainsIdentifier("New")) { // "New" can be explicitly accessed in xml doc comments to reference a constructor. return true; } } return false; }, cancellationToken)); }
protected override Task <ImmutableArray <Document> > DetermineDocumentsToSearchAsync( IMethodSymbol symbol, Project project, IImmutableSet <Document> documents, FindReferencesSearchOptions options, CancellationToken cancellationToken) { return(FindDocumentsAsync(project, documents, async(d, c) => { var index = await SyntaxTreeIndex.GetIndexAsync(d, c).ConfigureAwait(false); if (index.ContainsBaseConstructorInitializer) { return true; } if (index.ProbablyContainsIdentifier(symbol.ContainingType.Name)) { if (index.ContainsThisConstructorInitializer) { return true; } } return false; }, cancellationToken)); }
public static async ValueTask <SyntaxTreeIndex> GetSyntaxTreeIndexAsync(this Document document, CancellationToken cancellationToken) { var result = await SyntaxTreeIndex.GetIndexAsync(document, loadOnly : false, cancellationToken).ConfigureAwait(false); Contract.ThrowIfNull(result); return(result); }
private Task <ImmutableArray <Document> > FindDocumentWithElementAccessExpressionsAsync( Project project, IImmutableSet <Document> documents, CancellationToken cancellationToken) { return(FindDocumentsAsync(project, documents, async(d, c) => { var info = await SyntaxTreeIndex.GetIndexAsync(d, c).ConfigureAwait(false); return info.ContainsElementAccessExpression; }, cancellationToken)); }
public void AddItem(SyntaxTreeIndex syntaxIndex) { foreach (var(receiverType, symbolInfoIndices) in syntaxIndex.ReceiverTypeNameToExtensionMethodMap) { foreach (var index in symbolInfoIndices) { _mapBuilder.Add(receiverType, syntaxIndex.DeclaredSymbolInfos[index]); } } }
public override Task AnalyzeSyntaxAsync(Document document, InvocationReasons reasons, CancellationToken cancellationToken) { if (!document.SupportsSyntaxTree) { // Not a language we can produce indices for (i.e. TypeScript). Bail immediately. return(Task.CompletedTask); } return(SyntaxTreeIndex.PrecalculateAsync(document, cancellationToken)); }
/// <summary> /// Finds all the documents in the provided project that contain a global attribute in them. /// </summary> protected static Task <ImmutableArray <Document> > FindDocumentsWithGlobalAttributesAsync( Project project, IImmutableSet <Document>?documents, CancellationToken cancellationToken) { return(FindDocumentsAsync(project, documents, async(d, c) => { var info = await SyntaxTreeIndex.GetRequiredIndexAsync(d, c).ConfigureAwait(false); return info.ContainsGlobalAttributes; }, cancellationToken)); }
public override Task AnalyzeSyntaxAsync(Document document, InvocationReasons reasons, CancellationToken cancellationToken) { if (document.Project.Solution.Workspace.Kind != WorkspaceKind.RemoteWorkspace && document.Project.Solution.Workspace.Options.GetOption(SymbolFinderOptions.OutOfProcessAllowed)) { // if FAR feature is set to run on remote host, then we don't need to build inproc cache. // remote host will build this cache in remote host. return(SpecializedTasks.EmptyTask); } return(SyntaxTreeIndex.PrecalculateAsync(document, cancellationToken)); }
public override async Task AnalyzeSyntaxAsync(Document document, InvocationReasons reasons, CancellationToken cancellationToken) { if (!document.SupportsSyntaxTree) { // Not a language we can produce indices for (i.e. TypeScript). Bail immediately. return; } await SyntaxTreeIndex.PrecalculateAsync(document, cancellationToken).ConfigureAwait(false); await TopLevelSyntaxTreeIndex.PrecalculateAsync(document, cancellationToken).ConfigureAwait(false); }
protected Task <ImmutableArray <Document> > FindDocumentsAsync( Project project, IImmutableSet <Document> documents, PredefinedType predefinedType, CancellationToken cancellationToken) { return(FindDocumentsAsync(project, documents, async(d, c) => { var info = await SyntaxTreeIndex.GetIndexAsync(d, c).ConfigureAwait(false); return info.ContainsPredefinedType(predefinedType); }, cancellationToken)); }
protected static Task<ImmutableArray<Document>> FindDocumentsAsync( Project project, IImmutableSet<Document>? documents, PredefinedOperator op, CancellationToken cancellationToken) { if (op == PredefinedOperator.None) return SpecializedTasks.EmptyImmutableArray<Document>(); return FindDocumentsAsync(project, documents, async (d, c) => { var info = await SyntaxTreeIndex.GetRequiredIndexAsync(d, c).ConfigureAwait(false); return info.ContainsPredefinedOperator(op); }, cancellationToken); }
public void AddItem(SyntaxTreeIndex syntaxIndex) { foreach (var(targetType, symbolInfoIndices) in syntaxIndex.SimpleExtensionMethodInfo) { foreach (var index in symbolInfoIndices) { _simpleItemBuilder.Add(targetType, syntaxIndex.DeclaredSymbolInfos[index]); } } foreach (var index in syntaxIndex.ComplexExtensionMethodInfo) { _complexItemBuilder.Add(syntaxIndex.DeclaredSymbolInfos[index]); } }
public override Task AnalyzeSyntaxAsync(Document document, InvocationReasons reasons, CancellationToken cancellationToken) { if (!document.SupportsSyntaxTree) { // Not a language we can produce indices for (i.e. TypeScript). Bail immediately. return(Task.CompletedTask); } if (!RemoteFeatureOptions.ShouldComputeIndex(document.Project.Solution.Workspace)) { return(Task.CompletedTask); } return(SyntaxTreeIndex.PrecalculateAsync(document, cancellationToken)); }
/// <summary> /// Finds all the documents in the provided project that contain the requested string /// values /// </summary> protected Task <ImmutableArray <Document> > FindDocumentsAsync(Project project, IImmutableSet <Document> documents, CancellationToken cancellationToken, params string[] values) { return(FindDocumentsAsync(project, documents, async(d, c) => { var info = await SyntaxTreeIndex.GetIndexAsync(d, c).ConfigureAwait(false); foreach (var value in values) { if (!info.ProbablyContainsIdentifier(value)) { return false; } } return true; }, cancellationToken)); }
protected async Task <ImmutableArray <Document> > FindDocumentsAsync( Project project, IImmutableSet <Document> documents, PredefinedOperator op, CancellationToken cancellationToken) { if (op == PredefinedOperator.None) { return(ImmutableArray <Document> .Empty); } return(await FindDocumentsAsync(project, documents, async (d, c) => { var info = await SyntaxTreeIndex.GetIndexAsync(d, c).ConfigureAwait(false); return info.ContainsPredefinedOperator(op); }, cancellationToken).ConfigureAwait(false)); }
protected static async Task <ImmutableArray <string> > GetAllMatchingGlobalAliasNamesAsync( Project project, string name, int arity, CancellationToken cancellationToken) { using var result = TemporaryArray <string> .Empty; foreach (var document in await project.GetAllRegularAndSourceGeneratedDocumentsAsync(cancellationToken).ConfigureAwait(false)) { var index = await SyntaxTreeIndex.GetRequiredIndexAsync(document, cancellationToken).ConfigureAwait(false); foreach (var alias in index.GetGlobalAliases(name, arity)) { result.Add(alias); } } return(result.ToImmutableAndClear()); }
public async Task RunSerialIndexing() { Console.WriteLine("start profiling now"); // Thread.Sleep(10000); Console.WriteLine("Starting serial indexing"); var start = DateTime.Now; foreach (var project in _workspace.CurrentSolution.Projects) { foreach (var document in project.Documents) { // await WalkTree(document); await SyntaxTreeIndex.PrecalculateAsync(document, default).ConfigureAwait(false); } } Console.WriteLine("Serial: " + (DateTime.Now - start)); Console.ReadLine(); }
private async Task AddDocumentsWithPotentialConflicts(IEnumerable <Document> documents) { try { foreach (var document in documents) { if (_documentsIdsToBeCheckedForConflict.Contains(document.Id)) { continue; } var info = await SyntaxTreeIndex.GetIndexAsync(document, CancellationToken.None).ConfigureAwait(false); if (info.ProbablyContainsEscapedIdentifier(_originalText)) { _documentsIdsToBeCheckedForConflict.Add(document.Id); continue; } if (info.ProbablyContainsIdentifier(_replacementText)) { _documentsIdsToBeCheckedForConflict.Add(document.Id); continue; } foreach (var replacementName in _possibleNameConflicts) { if (info.ProbablyContainsIdentifier(replacementName)) { _documentsIdsToBeCheckedForConflict.Add(document.Id); break; } } } } catch (Exception e) when(FatalError.ReportUnlessCanceled(e)) { throw ExceptionUtilities.Unreachable; } }
public async Task RunFullParallelIndexing() { Console.WriteLine("Attach now"); Console.ReadLine(); Console.WriteLine("Starting indexing"); var start = DateTime.Now; var tasks = _workspace.CurrentSolution.Projects.SelectMany(p => p.Documents).Select(d => Task.Run( () => SyntaxTreeIndex.PrecalculateAsync(d, default))).ToList(); await Task.WhenAll(tasks); Console.WriteLine("Solution parallel: " + (DateTime.Now - start)); }
public static ValueTask <SyntaxTreeIndex> GetSyntaxTreeIndexAsync(this Document document, CancellationToken cancellationToken) => SyntaxTreeIndex.GetIndexAsync(document, loadOnly: false, cancellationToken);
public static Task <SyntaxTreeIndex> GetSyntaxTreeIndexAsync(this Document document, bool loadOnly, CancellationToken cancellationToken) => SyntaxTreeIndex.GetIndexAsync(document, loadOnly, cancellationToken);
public override Task AnalyzeSyntaxAsync(Document document, InvocationReasons reasons, CancellationToken cancellationToken) { return(SyntaxTreeIndex.PrecalculateAsync(document, cancellationToken)); }