static void TestVersion(ISymbol symbol, Compilation compilation, int version) { var id = SymbolKey.CreateStringWorker(version, symbol); Assert.NotNull(id); var found = SymbolKey.ResolveString(id, compilation).GetAnySymbol(); Assert.Null(found); }
public async Task <ISymbol> TryRehydrateAsync( Solution solution, CancellationToken cancellationToken) { var projectId = ProjectId; var project = solution.GetProject(projectId); var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); // The server and client should both be talking about the same compilation. As such // locations in symbols are save to resolve as we rehydrate the SymbolKey. var symbol = SymbolKey.ResolveString( SymbolKeyData, compilation, resolveLocations: true, cancellationToken: cancellationToken).GetAnySymbol(); if (symbol == null) { try { throw new InvalidOperationException( $"We should always be able to resolve a symbol back on the host side:\r\n{SymbolKeyData}"); } catch (Exception ex) when(FatalError.ReportWithoutCrash(ex)) { return(null); } } return(symbol); }
private static void NavigateToQuickInfoTarget( string navigationTarget, Workspace workspace, DocumentId documentId, IThreadingContext threadingContext, IStreamingFindUsagesPresenter streamingPresenter) { var solution = workspace.CurrentSolution; SymbolKeyResolution resolvedSymbolKey; try { var project = solution.GetRequiredProject(documentId.ProjectId); resolvedSymbolKey = SymbolKey.ResolveString(navigationTarget, project.GetRequiredCompilationAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None), cancellationToken: CancellationToken.None); } catch { // Ignore symbol resolution failures. It likely is just a badly formed URI. return; } if (resolvedSymbolKey.GetAnySymbol() is { } symbol) { GoToDefinitionHelpers.TryGoToDefinition(symbol, solution, threadingContext, streamingPresenter, CancellationToken.None); return; } }
private static void NavigateToQuickInfoTarget(string navigationTarget, Document document, IStreamingFindUsagesPresenter streamingPresenter) { var navigateToLinkService = document.Project.Solution.Workspace.Services.GetRequiredService <INavigateToLinkService>(); if (Uri.TryCreate(navigationTarget, UriKind.Absolute, out var absoluteUri)) { navigateToLinkService.TryNavigateToLinkAsync(absoluteUri, CancellationToken.None); return; } SymbolKeyResolution resolvedSymbolKey; try { resolvedSymbolKey = SymbolKey.ResolveString(navigationTarget, document.Project.GetCompilationAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None), cancellationToken: CancellationToken.None); } catch { // Ignore symbol resolution failures. It likely is just a badly formed URI. return; } if (resolvedSymbolKey.GetAnySymbol() is { } symbol) { GoToDefinitionHelpers.TryGoToDefinition(symbol, document.Project, streamingPresenter, CancellationToken.None); return; } }
public Task <(IList <SerializableImportCompletionItem>, StatisticCounter)> GetUnimportedExtensionMethodsAsync( DocumentId documentId, int position, string receiverTypeSymbolKeyData, string[] namespaceInScope, bool forceIndexCreation, CancellationToken cancellationToken) { return(RunServiceAsync(async() => { using (UserOperationBooster.Boost()) { var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false); var document = solution.GetDocument(documentId) !; var compilation = (await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false)); var symbol = SymbolKey.ResolveString(receiverTypeSymbolKeyData, compilation, cancellationToken: cancellationToken).GetAnySymbol(); if (symbol is ITypeSymbol receiverTypeSymbol) { var syntaxFacts = document.GetRequiredLanguageService <ISyntaxFactsService>(); var namespaceInScopeSet = new HashSet <string>(namespaceInScope, syntaxFacts.StringComparer); var(items, counter) = await ExtensionMethodImportCompletionHelper.GetUnimportedExtensionMethodsInCurrentProcessAsync( document, position, receiverTypeSymbol, namespaceInScopeSet, forceIndexCreation, cancellationToken).ConfigureAwait(false); return ((IList <SerializableImportCompletionItem>)items, counter); } return (Array.Empty <SerializableImportCompletionItem>(), new StatisticCounter()); } }, cancellationToken)); }
private (Project project, ISymbol symbol) TryResolveSymbolInCurrentSolution( Workspace workspace, string symbolKey ) { if ( !Properties.TryGetValue( MetadataSymbolOriginatingProjectIdGuid, out var projectIdGuid ) || !Properties.TryGetValue( MetadataSymbolOriginatingProjectIdDebugName, out var projectDebugName ) ) { return (null, null); } var project = workspace.CurrentSolution.GetProject( ProjectId.CreateFromSerialized(Guid.Parse(projectIdGuid), projectDebugName) ); if (project == null) { return (null, null); } var compilation = project .GetCompilationAsync(CancellationToken.None) .WaitAndGetResult(CancellationToken.None); var symbol = SymbolKey.ResolveString(symbolKey, compilation).Symbol; return (project, symbol); }
private static ISymbol?GetSymbol(CompletionItem item, Compilation compilation) { // If we have SymbolKey data (i.e. this is an extension method item), use it to recover symbol if (item.Properties.TryGetValue(SymbolKeyData, out var symbolId)) { return(SymbolKey.ResolveString(symbolId, compilation).GetAnySymbol()); } // Otherwise, this is a type item, so we don't have SymbolKey data. But we should still have all // the data to construct its full metadata name var containingNamespace = GetContainingNamespace(item); var typeName = item.Properties.TryGetValue(AttributeFullName, out var attributeFullName) ? attributeFullName : item.DisplayText; var fullyQualifiedName = GetFullyQualifiedName(containingNamespace, typeName); if (item.Properties.TryGetValue(TypeAritySuffixName, out var aritySuffix)) { return(compilation.GetTypeByMetadataName(fullyQualifiedName + aritySuffix)); } return(compilation.GetTypeByMetadataName(fullyQualifiedName)); }
public Task <(DocumentId, TextChange[])[]> EncapsulateFieldsAsync( PinnedSolutionInfo solutionInfo, DocumentId documentId, ImmutableArray <string> fieldSymbolKeys, bool updateReferences, CancellationToken cancellationToken) { return(RunServiceAsync(async() => { using (UserOperationBooster.Boost()) { var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false); var document = solution.GetRequiredDocument(documentId); using var _ = ArrayBuilder <IFieldSymbol> .GetInstance(out var fields); var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); foreach (var key in fieldSymbolKeys) { var resolved = SymbolKey.ResolveString(key, compilation, cancellationToken: cancellationToken).GetAnySymbol() as IFieldSymbol; if (resolved == null) { return Array.Empty <(DocumentId, TextChange[])>(); }
private static void NavigateToQuickInfoTarget( string navigationTarget, Document document, IThreadingContext threadingContext, IStreamingFindUsagesPresenter streamingPresenter) { SymbolKeyResolution resolvedSymbolKey; try { resolvedSymbolKey = SymbolKey.ResolveString(navigationTarget, document.Project.GetCompilationAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None), cancellationToken: CancellationToken.None); } catch { // Ignore symbol resolution failures. It likely is just a badly formed URI. return; } if (resolvedSymbolKey.GetAnySymbol() is { } symbol) { GoToDefinitionHelpers.TryGoToDefinition(symbol, document.Project.Solution, threadingContext, streamingPresenter, CancellationToken.None); return; } }
private static ISymbol?DecodeSymbol(string id, Compilation compilation) => SymbolKey.ResolveString(id, compilation).GetAnySymbol();
private static ISymbol DecodeSymbol(string id, Compilation compilation) { return(SymbolKey.ResolveString(id, compilation).GetAnySymbol()); }