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