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));
}
public Task FindReferencesAsync(SerializableSymbolAndProjectId symbolAndProjectIdArg, DocumentId[] documentArgs, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var symbolAndProjectId = await symbolAndProjectIdArg.TryRehydrateAsync(
solution, cancellationToken).ConfigureAwait(false);
var progressCallback = new FindReferencesProgressCallback(this);
if (!symbolAndProjectId.HasValue)
{
await progressCallback.OnStartedAsync().ConfigureAwait(false);
await progressCallback.OnCompletedAsync().ConfigureAwait(false);
return;
}
// NOTE: In projection scenarios, we might get a set of documents to search
// that are not all the same language and might not exist in the OOP process
// (like the JS parts of a .cshtml file). Filter them out here. This will
// need to be revisited if we someday support FAR between these languages.
var documents = documentArgs?.Select(solution.GetDocument)
.WhereNotNull()
.ToImmutableHashSet();
await SymbolFinder.FindReferencesInCurrentProcessAsync(
symbolAndProjectId.Value, solution,
progressCallback, documents, cancellationToken).ConfigureAwait(false);
}
}, cancellationToken));
}
/// <summary>
/// This is top level entry point for diagnostic calculation from client (VS).
///
/// This will be called by ServiceHub/JsonRpc framework
/// </summary>
public Task CalculateDiagnosticsAsync(DiagnosticArguments arguments, string streamName, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
// if this analysis is explicitly asked by user, boost priority of this request
using (RoslynLogger.LogBlock(FunctionId.CodeAnalysisService_CalculateDiagnosticsAsync, arguments.ProjectId.DebugName, cancellationToken))
using (arguments.ForcedAnalysis ? UserOperationBooster.Boost() : default)
{
try
{
// entry point for diagnostic service
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var optionSet = await RoslynServices.AssetService.GetAssetAsync <OptionSet>(arguments.OptionSetChecksum, cancellationToken).ConfigureAwait(false);
var projectId = arguments.ProjectId;
var analyzers = RoslynServices.AssetService.GetGlobalAssetsOfType <AnalyzerReference>(cancellationToken);
var result = await(new DiagnosticComputer(solution.GetProject(projectId))).GetDiagnosticsAsync(
analyzers, optionSet, arguments.AnalyzerIds, arguments.ReportSuppressedDiagnostics, arguments.LogAnalyzerExecutionTime, cancellationToken).ConfigureAwait(false);
await SerializeDiagnosticResultAsync(streamName, result, cancellationToken).ConfigureAwait(false);
}
catch (IOException)
{
// direct stream to send over result has closed before we
// had chance to check cancellation
}
}
}, cancellationToken));
}
public Task <SerializableConflictResolution> RenameSymbolAsync(
PinnedSolutionInfo solutionInfo,
SerializableSymbolAndProjectId symbolAndProjectId,
string newName,
SerializableRenameOptionSet options,
SerializableSymbolAndProjectId[] nonConflictSymbolIds,
CancellationToken cancellationToken)
{
return(RunServiceAsync <SerializableConflictResolution>(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var symbol = await symbolAndProjectId.TryRehydrateAsync(
solution, cancellationToken).ConfigureAwait(false);
if (symbol == null)
{
return null;
}
var nonConflictSymbols = await GetNonConflictSymbolsAsync(solution, nonConflictSymbolIds, cancellationToken).ConfigureAwait(false);
var result = await Renamer.RenameSymbolAsync(
solution, symbol, newName, options.Rehydrate(),
nonConflictSymbols, cancellationToken).ConfigureAwait(false);
return await result.DehydrateAsync(cancellationToken).ConfigureAwait(false);
}
}, cancellationToken));
}
private Task <ImmutableArray <SerializableSymbolAndProjectId> > FindAndCacheTypesAsync(
PinnedSolutionInfo solutionInfo,
SerializableSymbolAndProjectId typeAndProjectId,
ProjectId[] projectIds,
Func <INamedTypeSymbol, Solution, ImmutableHashSet <Project>, Task <ImmutableArray <INamedTypeSymbol> > > func,
CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var symbol = await typeAndProjectId.TryRehydrateAsync(
solution, cancellationToken).ConfigureAwait(false);
if (!(symbol is INamedTypeSymbol namedType))
{
return ImmutableArray <SerializableSymbolAndProjectId> .Empty;
}
var projects = projectIds?.Select(id => solution.GetProject(id)).ToImmutableHashSet();
var types = await func(namedType, solution, projects).ConfigureAwait(false);
return types.SelectAsArray(
(Func <INamedTypeSymbol, SerializableSymbolAndProjectId>)(t => SerializableSymbolAndProjectId.Dehydrate(solution, t, cancellationToken)));
}
}, cancellationToken));
}
/// <summary>
/// Calculate dignostics. this works differently than other ones such as todo comments or designer attribute scanner
/// since in proc and out of proc runs quite differently due to concurrency and due to possible amount of data
/// that needs to pass through between processes
/// </summary>
public Task CalculateDiagnosticsAsync(PinnedSolutionInfo solutionInfo, DiagnosticArguments arguments, string pipeName, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (RoslynLogger.LogBlock(FunctionId.CodeAnalysisService_CalculateDiagnosticsAsync, arguments.ProjectId.DebugName, cancellationToken))
using (arguments.IsHighPriority ? UserOperationBooster.Boost() : default)
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var documentId = arguments.DocumentId;
var projectId = arguments.ProjectId;
var project = solution.GetProject(projectId);
var documentSpan = arguments.DocumentSpan;
var documentAnalysisKind = arguments.DocumentAnalysisKind;
var diagnosticComputer = new DiagnosticComputer(documentId, project, documentSpan, documentAnalysisKind, _analyzerInfoCache);
var result = await diagnosticComputer.GetDiagnosticsAsync(
arguments.AnalyzerIds,
reportSuppressedDiagnostics: arguments.ReportSuppressedDiagnostics,
logPerformanceInfo: arguments.LogPerformanceInfo,
getTelemetryInfo: arguments.GetTelemetryInfo,
cancellationToken).ConfigureAwait(false);
await RemoteEndPoint.WriteDataToNamedPipeAsync(pipeName, (result, documentAnalysisKind), (writer, data, cancellationToken) =>
{
var(diagnostics, telemetry) = DiagnosticResultSerializer.WriteDiagnosticAnalysisResults(writer, data.documentAnalysisKind, data.result, cancellationToken);
// save log for debugging
Log(TraceEventType.Information, $"diagnostics: {diagnostics}, telemetry: {telemetry}");
return Task.CompletedTask;
}, cancellationToken).ConfigureAwait(false);
}
}, cancellationToken));
}
public Task <SerializableRenameLocations> FindRenameLocationsAsync(
PinnedSolutionInfo solutionInfo,
SerializableSymbolAndProjectId symbolAndProjectId,
SerializableRenameOptionSet options,
CancellationToken cancellationToken)
{
return(RunServiceAsync <SerializableRenameLocations>(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var symbol = await symbolAndProjectId.TryRehydrateAsync(
solution, cancellationToken).ConfigureAwait(false);
if (symbol == null)
{
return null;
}
var result = await RenameLocations.FindLocationsAsync(
symbol, solution, options.Rehydrate(), cancellationToken).ConfigureAwait(false);
return result.Dehydrate(solution, cancellationToken);
}
}, cancellationToken));
}
public Task <SerializableConvertTupleToStructResult> ConvertToStructAsync(
PinnedSolutionInfo solutionInfo,
DocumentId documentId,
TextSpan span,
Scope scope,
CancellationToken cancellationToken)
{
return(RunServiceAsync <SerializableConvertTupleToStructResult>(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var document = solution.GetDocument(documentId);
var service = document.GetLanguageService <IConvertTupleToStructCodeRefactoringProvider>();
var updatedSolution = await service.ConvertToStructAsync(document, span, scope, cancellationToken).ConfigureAwait(false);
var cleanedSolution = await CleanupAsync(solution, updatedSolution, cancellationToken).ConfigureAwait(false);
var documentTextChanges = await RemoteUtilities.GetDocumentTextChangesAsync(
solution, cleanedSolution, cancellationToken).ConfigureAwait(false);
var renamedToken = await GetRenamedTokenAsync(
solution, cleanedSolution, cancellationToken).ConfigureAwait(false);
return new SerializableConvertTupleToStructResult
{
DocumentTextChanges = documentTextChanges,
RenamedToken = renamedToken,
};
}
}, cancellationToken));
}
public Task FindImplementationsAsync(
PinnedSolutionInfo solutionInfo,
SerializableSymbolAndProjectId symbolAndProjectIdArg,
CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var project = solution.GetProject(symbolAndProjectIdArg.ProjectId);
var symbol = await symbolAndProjectIdArg.TryRehydrateAsync(
solution, cancellationToken).ConfigureAwait(false);
if (symbol == null)
{
return;
}
var context = new RemoteFindUsageContext(solution, EndPoint, cancellationToken);
await AbstractFindUsagesService.FindImplementationsAsync(
symbol, project, context).ConfigureAwait(false);
}
}, cancellationToken));
}
public async Task FindReferencesAsync(SerializableSymbolAndProjectId symbolAndProjectIdArg, DocumentId[] documentArgs)
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync().ConfigureAwait(false);
var symbolAndProjectId = await symbolAndProjectIdArg.TryRehydrateAsync(
solution, CancellationToken).ConfigureAwait(false);
var progressCallback = new FindReferencesProgressCallback(this);
if (!symbolAndProjectId.HasValue)
{
await progressCallback.OnStartedAsync().ConfigureAwait(false);
await progressCallback.OnCompletedAsync().ConfigureAwait(false);
return;
}
var documents = documentArgs?.Select(solution.GetDocument)
.ToImmutableHashSet();
await SymbolFinder.FindReferencesInCurrentProcessAsync(
symbolAndProjectId.Value, solution,
progressCallback, documents, CancellationToken).ConfigureAwait(false);
}
}
public Task <SerializableConflictResolution?> ResolveConflictsAsync(
PinnedSolutionInfo solutionInfo,
SerializableRenameLocations renameLocationSet,
string replacementText,
SerializableSymbolAndProjectId[] nonConflictSymbolIds,
CancellationToken cancellationToken)
{
return(RunServiceAsync <SerializableConflictResolution?>(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var nonConflictSymbols = await GetNonConflictSymbolsAsync(solution, nonConflictSymbolIds, cancellationToken).ConfigureAwait(false);
var rehydratedSet = await RenameLocations.TryRehydrateAsync(solution, renameLocationSet, cancellationToken).ConfigureAwait(false);
if (rehydratedSet == null)
{
return null;
}
var result = await ConflictResolver.ResolveConflictsAsync(
rehydratedSet,
replacementText,
nonConflictSymbols,
cancellationToken).ConfigureAwait(false);
return await result.DehydrateAsync(cancellationToken).ConfigureAwait(false);
}
}, cancellationToken));
}
/// <summary>
/// Calculate dignostics. this works differently than other ones such as todo comments or designer attribute scanner
/// since in proc and out of proc runs quite differently due to concurrency and due to possible amount of data
/// that needs to pass through between processes
/// </summary>
public Task CalculateDiagnosticsAsync(DiagnosticArguments arguments, string pipeName, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
// if this analysis is explicitly asked by user, boost priority of this request
using (RoslynLogger.LogBlock(FunctionId.CodeAnalysisService_CalculateDiagnosticsAsync, arguments.ProjectId.DebugName, cancellationToken))
using (arguments.ForcedAnalysis ? UserOperationBooster.Boost() : default)
{
// entry point for diagnostic service
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var projectId = arguments.ProjectId;
var analyzers = RoslynServices.AssetService.GetGlobalAssetsOfType <AnalyzerReference>(cancellationToken);
var result = await new DiagnosticComputer(solution.GetProject(projectId)).GetDiagnosticsAsync(
analyzers, arguments.AnalyzerIds, arguments.ReportSuppressedDiagnostics, arguments.LogAnalyzerExecutionTime, cancellationToken).ConfigureAwait(false);
await RemoteEndPoint.WriteDataToNamedPipeAsync(pipeName, result, (writer, data, cancellationToken) =>
{
var(diagnostics, telemetry, exceptions) = DiagnosticResultSerializer.WriteDiagnosticAnalysisResults(writer, data, cancellationToken);
// save log for debugging
Log(TraceEventType.Information, $"diagnostics: {diagnostics}, telemetry: {telemetry}, exceptions: {exceptions}");
return Task.CompletedTask;
}, cancellationToken).ConfigureAwait(false);
}
}, cancellationToken));
}
public async Task FindLiteralReferencesAsync(object value, TypeCode typeCode, CancellationToken cancellationToken)
{
using (UserOperationBooster.Boost())
{
var convertedType = System.Convert.ChangeType(value, typeCode);
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var progressCallback = new FindLiteralReferencesProgressCallback(this);
await SymbolFinder.FindLiteralReferencesInCurrentProcessAsync(
convertedType, solution, progressCallback, cancellationToken).ConfigureAwait(false);
}
}
public Task <SymbolInformation[]?> WorkspaceSymbolAsync(WorkspaceSymbolParams args, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
// for now, we use whatever solution we have currently. in future, we will add an ability to sync VS's current solution
// on demand from OOP side
// https://github.com/dotnet/roslyn/issues/37424
return await SearchAsync(GetWorkspace().CurrentSolution, args, cancellationToken).ConfigureAwait(false);
}
}, cancellationToken));
}
public async Task <IList <SerializableSymbolAndProjectId> > FindSolutionSourceDeclarationsWithNormalQueryAsync(
string name, bool ignoreCase, SymbolFilter criteria, CancellationToken cancellationToken)
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var result = await DeclarationFinder.FindSourceDeclarationsWithNormalQueryInCurrentProcessAsync(
solution, name, ignoreCase, criteria, cancellationToken).ConfigureAwait(false);
return(result.SelectAsArray(SerializableSymbolAndProjectId.Dehydrate));
}
}
public Task <VSBeginSymbolParams> BeginWorkspaceSymbolAsync(string query, int searchId, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
// for now, we use whatever solution we have currently. in future, we will add an ability to sync VS's current solution
// on demand from OOP side
// https://github.com/dotnet/roslyn/issues/37424
await SearchAsync(SolutionService.PrimaryWorkspace.CurrentSolution, query, searchId, cancellationToken).ConfigureAwait(false);
return new VSBeginSymbolParams();
}
}, cancellationToken));
}
public async Task <ImmutableArray <SerializableNavigateToSearchResult> > SearchProjectAsync(
ProjectId projectId, string searchPattern, CancellationToken cancellationToken)
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var project = solution.GetProject(projectId);
var result = await AbstractNavigateToSearchService.SearchProjectInCurrentProcessAsync(
project, searchPattern, cancellationToken).ConfigureAwait(false);
return(Convert(result));
}
}
public async Task <IList <SerializableSymbolAndProjectId> > FindProjectSourceDeclarationsWithPatternAsync(
ProjectId projectId, string pattern, SymbolFilter criteria, CancellationToken cancellationToken)
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var project = solution.GetProject(projectId);
var result = await DeclarationFinder.FindSourceDeclarationsWithPatternInCurrentProcessAsync(
project, pattern, criteria, cancellationToken).ConfigureAwait(false);
return(result.SelectAsArray(SerializableSymbolAndProjectId.Dehydrate));
}
}
public Task FindLiteralReferencesAsync(PinnedSolutionInfo solutionInfo, object value, TypeCode typeCode, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
var convertedType = System.Convert.ChangeType(value, typeCode);
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var progressCallback = new FindLiteralReferencesProgressCallback(EndPoint, cancellationToken);
await SymbolFinder.FindLiteralReferencesInCurrentProcessAsync(
convertedType, solution, progressCallback, cancellationToken).ConfigureAwait(false);
}
}, cancellationToken));
}
public Task <IList <SerializableSymbolAndProjectId> > FindSolutionSourceDeclarationsWithPatternAsync(
string pattern, SymbolFilter criteria, CancellationToken cancellationToken)
{
return(RunServiceAsync(async token =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(token).ConfigureAwait(false);
var result = await DeclarationFinder.FindSourceDeclarationsWithPatternInCurrentProcessAsync(
solution, pattern, criteria, token).ConfigureAwait(false);
return (IList <SerializableSymbolAndProjectId>)result.SelectAsArray(SerializableSymbolAndProjectId.Dehydrate);
}
}, cancellationToken));
}
public Task <ImmutableArray <SerializableSymbolAndProjectId> > FindSolutionSourceDeclarationsWithPatternAsync(
PinnedSolutionInfo solutionInfo, string pattern, SymbolFilter criteria, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var result = await DeclarationFinder.FindSourceDeclarationsWithPatternInCurrentProcessAsync(
solution, pattern, criteria, cancellationToken).ConfigureAwait(false);
return Convert(result, solution, cancellationToken);
}
}, cancellationToken));
}
public Task <IList <SerializableSymbolAndProjectId> > FindProjectSourceDeclarationsWithNormalQueryAsync(
ProjectId projectId, string name, bool ignoreCase, SymbolFilter criteria, CancellationToken cancellationToken)
{
return(RunServiceAsync(async token =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(token).ConfigureAwait(false);
var project = solution.GetProject(projectId);
var result = await DeclarationFinder.FindSourceDeclarationsWithNormalQueryInCurrentProcessAsync(
project, name, ignoreCase, criteria, token).ConfigureAwait(false);
return (IList <SerializableSymbolAndProjectId>)result.SelectAsArray(SerializableSymbolAndProjectId.Dehydrate);
}
}, cancellationToken));
}
public Task <IList <SerializableNavigateToSearchResult> > SearchDocumentAsync(
DocumentId documentId, string searchPattern, string[] kinds, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var project = solution.GetDocument(documentId);
var result = await AbstractNavigateToSearchService.SearchDocumentInCurrentProcessAsync(
project, searchPattern, kinds.ToImmutableHashSet(), cancellationToken).ConfigureAwait(false);
return Convert(result);
}
}, cancellationToken));
}
public async Task <IList <SerializableSymbolAndProjectId> > FindAllDeclarationsWithNormalQueryAsync(
ProjectId projectId, string name, SearchKind searchKind, SymbolFilter criteria, CancellationToken cancellationToken)
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var project = solution.GetProject(projectId);
using (var query = SearchQuery.Create(name, searchKind))
{
var result = await DeclarationFinder.FindAllDeclarationsWithNormalQueryInCurrentProcessAsync(
project, query, criteria, cancellationToken).ConfigureAwait(false);
return(result.SelectAsArray(SerializableSymbolAndProjectId.Dehydrate));
}
}
}
public Task <SerializableClassifiedSpans> GetSemanticClassificationsAsync(
PinnedSolutionInfo solutionInfo, DocumentId documentId,
TextSpan span, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var document = solution.GetDocument(documentId);
using var _ = ArrayBuilder <ClassifiedSpan> .GetInstance(out var temp);
await AbstractClassificationService.AddSemanticClassificationsInCurrentProcessAsync(
document, span, temp, cancellationToken).ConfigureAwait(false);
return SerializableClassifiedSpans.Dehydrate(temp.ToImmutable());
}
}, cancellationToken));
}
public Task <IList <SerializableNavigateToSearchResult> > SearchProjectAsync(
PinnedSolutionInfo solutionInfo, ProjectId projectId, DocumentId[] priorityDocumentIds, string searchPattern, string[] kinds, CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var project = solution.GetProject(projectId);
var priorityDocuments = priorityDocumentIds.Select(d => solution.GetDocument(d))
.ToImmutableArray();
var result = await AbstractNavigateToSearchService.SearchProjectInCurrentProcessAsync(
project, priorityDocuments, searchPattern, kinds.ToImmutableHashSet(), cancellationToken).ConfigureAwait(false);
return Convert(result);
}
}, cancellationToken));
}
public async Task <ImmutableArray <AddImportFixData> > GetFixesAsync(
DocumentId documentId, TextSpan span, string diagnosticId,
bool searchReferenceAssemblies, ImmutableArray <PackageSource> packageSources)
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync().ConfigureAwait(false);
var document = solution.GetDocument(documentId);
var service = document.GetLanguageService <IAddImportFeatureService>();
var symbolSearchService = new SymbolSearchService(this);
var result = await service.GetFixesAsync(
document, span, diagnosticId, symbolSearchService, searchReferenceAssemblies,
packageSources, CancellationToken).ConfigureAwait(false);
return(result);
}
}
public Task <ImmutableArray <SerializableSymbolAndProjectId> > FindProjectSourceDeclarationsWithNormalQueryAsync(
PinnedSolutionInfo solutionInfo,
ProjectId projectId,
string name,
bool ignoreCase,
SymbolFilter criteria,
CancellationToken cancellationToken)
{
return(RunServiceAsync(async() =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
var project = solution.GetProject(projectId);
var result = await DeclarationFinder.FindSourceDeclarationsWithNormalQueryInCurrentProcessAsync(
project, name, ignoreCase, criteria, cancellationToken).ConfigureAwait(false);
return Convert(result, solution, cancellationToken);
}
}, cancellationToken));
}
public Task <IList <AddImportFixData> > GetFixesAsync(
DocumentId documentId, TextSpan span, string diagnosticId, bool placeSystemNamespaceFirst,
bool searchReferenceAssemblies, IList <PackageSource> packageSources, CancellationToken cancellationToken)
{
return(RunServiceAsync(async token =>
{
using (UserOperationBooster.Boost())
{
var solution = await GetSolutionAsync(token).ConfigureAwait(false);
var document = solution.GetDocument(documentId);
var service = document.GetLanguageService <IAddImportFeatureService>();
var symbolSearchService = new SymbolSearchService(this);
var result = await service.GetFixesAsync(
document, span, diagnosticId, placeSystemNamespaceFirst,
symbolSearchService, searchReferenceAssemblies,
packageSources.ToImmutableArray(), token).ConfigureAwait(false);
return (IList <AddImportFixData>)result;
}
}, cancellationToken));
}
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[])>();
}