Project

Workspace\Solution\Solution.cs (1)

169return new Project(solution, state);

FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAnalysisTests.cs (3)

64Project project = CreateProject([source, TestTypeToTrackSource]); 1320protected static Project CreateProject(string[] sources) 1333Project project = new AdhocWorkspace().CurrentSolution

Options\SymbolNamesWithValueOptionTests.cs (1)

428var project = new AdhocWorkspace().CurrentSolution

CodeRefactoringRunner.cs (1)

55foreach (var project in solution.Projects)

DiagnosticAnalyzerRunner.cs (7)

45var project = solution.GetProject(projectId)!; 95foreach (var project in solution.Projects) 107var project = solution.GetProject(projectId); 153var project = solution.GetProject(projectId); 178private static async Task<DocumentAnalyzerPerformance> TestDocumentPerformanceAsync(ImmutableDictionary<string, ImmutableArray<DiagnosticAnalyzer>> analyzers, Project project, DocumentId documentId, Options analyzerOptionsInternal, CancellationToken cancellationToken) 327foreach (var project in solution.Projects) 381Project project,

Program.cs (2)

148foreach (var project in projects) 188private static Statistic GetSolutionStatistics(IEnumerable<Project> projects, CancellationToken cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixesAndRefactorings\FixAllHelper.cs (1)

15Project triggerProject)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ISolutionExtensions.cs (2)

38public static Project GetRequiredProject(this Solution solution, ProjectId projectId) 40var project = solution.GetProject(projectId);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (9)

17public static TLanguageService? GetLanguageService<TLanguageService>(this Project? project) where TLanguageService : class, ILanguageService 24public static TLanguageService GetRequiredLanguageService<TLanguageService>(this Project project) where TLanguageService : class, ILanguageService 33/// Gets extended host language services, which includes language services from <see cref="Project.LanguageServices"/>. 35public static HostLanguageServices GetExtendedLanguageServices(this Project project) 44public static string? TryGetAnalyzerConfigPathForProjectConfiguration(this Project project) 47public static string? TryGetAnalyzerConfigPathForDiagnosticConfiguration(this Project project, Diagnostic diagnostic) 53private static string? TryGetAnalyzerConfigPathForProjectOrDiagnosticConfiguration(Project project, Diagnostic? diagnostic) 101public static AnalyzerConfigDocument? TryGetExistingAnalyzerConfigDocumentAtPath(this Project project, string analyzerConfigPath) 109public static async Task<Compilation> GetRequiredCompilationAsync(this Project project, CancellationToken cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (2)

59foreach (var sourceProject in solution.Projects) 77var project = solution.GetProject(symbol.ContainingAssembly, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

25public Project Project => Document.Project;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

12public static bool CanApplyParseOptionChange(this Project project, ParseOptions oldOptions, ParseOptions newOptions)

InheritanceMargin\BenchmarksHelpers.cs (1)

22foreach (var project in solution.Projects)

ClassificationBenchmarks.cs (1)

94var project = _solution.Projects.First(p => p.AssemblyName == "Microsoft.CodeAnalysis");

FindReferencesBenchmarks.cs (1)

93var project = _solution.Projects.First(p => p.AssemblyName == "Microsoft.CodeAnalysis");

IncrementalSourceGeneratorBenchmarks.cs (1)

139var project = _workspace.CurrentSolution.Projects.Single(p => p.Name == "Microsoft.CodeAnalysis.Workspaces(netstandard2.0)");

NavigateToBenchmarks.cs (4)

109foreach (var project in _workspace.CurrentSolution.Projects) 143foreach (var project in _workspace.CurrentSolution.Projects) 162foreach (var project in _workspace.CurrentSolution.Projects) 224private async Task<int> SearchAsync(Solution solution, IGrouping<INavigateToSearchService, Project> grouping, ImmutableArray<Document> priorityDocuments)

ProjectOperationBenchmarks.cs (5)

23private Project _emptyProject; 24private Project _hundredProject; 25private Project _thousandsProject; 39private Project Project 63static Project CreateProject(ref Solution solution, string name, int documentCount)

RenameBenchmarks.cs (1)

46var project = _solution.Projects.First();

SwitchStatementBenchmarks.cs (1)

74var project = solution.Projects.First();

Program.cs (2)

306var project = await workspace.OpenProjectAsync(projectFile, cancellationToken: CancellationToken.None).ConfigureAwait(false); 339foreach (var project in solution.Projects)

src\RoslynAnalyzers\Tools\Metrics\Program.cs (2)

306var project = await workspace.OpenProjectAsync(projectFile, cancellationToken: CancellationToken.None).ConfigureAwait(false); 339foreach (var project in solution.Projects)

CallAnalysis\Fixers\LegacyLoggingFixer.cs (1)

264GetOrMakeTargetClassAsync(Project proj, FixDetails details, CancellationToken cancellationToken)

CallAnalysis\LegacyLoggingTests.cs (1)

815var proj = RoslynTestUtils

Resources\RoslynTestUtils.cs (18)

30public static Project CreateTestProject(IEnumerable<Assembly>? references, bool includeBaseReferences = true, 64public static void CommitChanges(this Project proj) 69public static Project WithDocument(this Project proj, string name, string text) 74public static Document FindDocument(this Project proj, string name) 182var proj = CreateTestProject(references, includeBaseReferences); 210var proj = CreateTestProject(references, includeBaseReferences); 242var proj = CreateTestProject(references, testAssemblyName: testAssemblyName); 298var proj = CreateTestProject(references, testAssemblyName: testAssemblyName); 363var changedProj = solution.GetProject(proj.Id); 413var proj = CreateTestProject(references); 457var changedProj = solution.GetProject(proj.Id); 492private static async Task<Project> RecreateProjectDocumentsAsync(Project project) 513Project project, 522public override async Task<IEnumerable<Diagnostic>> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) 533public override async Task<IEnumerable<Diagnostic>> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken) 549private Project _project;

Resources\RoslynTestUtils.cs (18)

30public static Project CreateTestProject(IEnumerable<Assembly>? references, bool includeBaseReferences = true, 64public static void CommitChanges(this Project proj) 69public static Project WithDocument(this Project proj, string name, string text) 74public static Document FindDocument(this Project proj, string name) 182var proj = CreateTestProject(references, includeBaseReferences); 210var proj = CreateTestProject(references, includeBaseReferences); 242var proj = CreateTestProject(references, testAssemblyName: testAssemblyName); 299var proj = CreateTestProject(references, testAssemblyName: testAssemblyName); 364var changedProj = solution.GetProject(proj.Id); 414var proj = CreateTestProject(references); 458var changedProj = solution.GetProject(proj.Id); 493private static async Task<Project> RecreateProjectDocumentsAsync(Project project) 514Project project, 523public override async Task<IEnumerable<Diagnostic>> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) 534public override async Task<IEnumerable<Diagnostic>> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken) 550private Project _project;

CodeFixRunner.cs (2)

36var updatedProject = updatedSolution.GetProject(document.Project.Id); 44private async Task EnsureCompilable(Project project)

DiagnosticAnalyzerRunner.cs (3)

37var project = DiagnosticProject.Create(GetType().Assembly, sources); 54IEnumerable<Project> projects, 60foreach (var project in projects)

DiagnosticProject.cs (1)

31public static Project Create(Assembly testAssembly, string[] sources, Func<Workspace> workspaceFactory = null, Type[] analyzerReferences = null)

DiagnosticVerifier.cs (4)

73var projects = new HashSet<Project>(); 80foreach (var project in projects) 141var project = CreateProject(sources); 154protected Project CreateProject(params string[] sources)

Infrastructure\WellKnownTypesTests.cs (1)

63var project = TestDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, source.Source);

TestDiagnosticAnalyzer.cs (7)

31var project = CreateProjectWithReferencesInBinDir(GetType().Assembly, sources); 48var project = CreateProjectWithReferencesInBinDir(GetType().Assembly, sources); 70var project = CreateProjectWithReferencesInBinDir(GetType().Assembly, sources); 109var project = CreateProjectWithReferencesInBinDir(GetType().Assembly, sources); 146public static Project CreateProjectWithReferencesInBinDir(Assembly testAssembly, params string[] source) 154var project = DiagnosticProject.Create(testAssembly, source, createWorkspace, [typeof(RoutePatternClassifier), typeof(ExtensionMethodsCompletionProvider)]); 166public Task<Diagnostic[]> GetDiagnosticsAsync(Project project)

AnalyzerTestBase.cs (1)

31public Project CreateProject(string source)

ComponentAnalyzerDiagnosticAnalyzerRunner.cs (1)

24public Task<Diagnostic[]> GetDiagnosticsAsync(Project project)

Helpers\DiagnosticVerifier.Helper.cs (4)

53var projects = new HashSet<Project>(); 60foreach (var project in projects) 116var project = CreateProject(sources, language); 144private static Project CreateProject(string[] sources, string language = LanguageNames.CSharp)

AnalyzerTestBase.cs (1)

31public Project CreateProject(string source)

ComponentAnalyzerDiagnosticAnalyzerRunner.cs (1)

24public Task<Diagnostic[]> GetDiagnosticsAsync(Project project)

Helpers\DiagnosticVerifier.Helper.cs (4)

53var projects = new HashSet<Project>(); 60foreach (var project in projects) 116var project = CreateProject(sources, language); 144private static Project CreateProject(string[] sources, string language = LanguageNames.CSharp)

RequestDelegateGenerator\CompileTimeCreationTests.cs (8)

53var project = CreateProject(); 79var project = CreateProject(); 158var project = CreateProject(modifyCompilationOptions: 231var project = CreateProject(); 285var project = CreateProject(); 332var project = CreateProject(); 668var project = CreateProject(); 725var project = CreateProject();

RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (4)

39private static readonly Project _baseProject = CreateProject(); 306var project = _baseProject.AddDocument("TestMapActions.cs", SourceText.From(source, Encoding.UTF8)).Project; 311internal static Project CreateProject(Func<CSharpCompilationOptions, CSharpCompilationOptions> modifyCompilationOptions = null) 320var project = new AdhocWorkspace().CurrentSolution

RequestDelegateGeneratorBenchmarks.cs (1)

25var project = CreateProject();

src\Http\Http.Extensions\test\RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (4)

39private static readonly Project _baseProject = CreateProject(); 306var project = _baseProject.AddDocument("TestMapActions.cs", SourceText.From(source, Encoding.UTF8)).Project; 311internal static Project CreateProject(Func<CSharpCompilationOptions, CSharpCompilationOptions> modifyCompilationOptions = null) 320var project = new AdhocWorkspace().CurrentSolution

MetaAnalyzers\Fixers\AnalyzerReleaseTrackingFix.cs (5)

105private static Task<Solution> AddAnalyzerReleaseTrackingFilesAsync(Project project) 112static Project AddAdditionalDocument(Project project, string name, string fileContent) 169private static async Task<Solution> AddEntryToUnshippedFileAsync(Project project, string entryToAdd, CancellationToken cancellationToken) 187private static async Task<Solution> UpdateEntryInUnshippedFileAsync(Project project, string ruleId, string entryToUpdate, CancellationToken cancellationToken)

MetaAnalyzers\Fixers\AnalyzerReleaseTrackingFix.FixAllProvider.cs (10)

27var diagnosticsToFix = new List<KeyValuePair<Project, ImmutableArray<Diagnostic>>>(); 33diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics)); 39Project project = fixAllContext.Project; 41diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics)); 47foreach (Project project in fixAllContext.Solution.Projects) 50diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(project, diagnostics)); 75private readonly List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> _diagnosticsToFix; 78public FixAllAdditionalDocumentChangeAction(FixAllScope fixAllScope, Solution solution, List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> diagnosticsToFix, string? equivalenceKey) 93foreach (KeyValuePair<Project, ImmutableArray<Diagnostic>> pair in _diagnosticsToFix) 95Project project = pair.Key;

MetaAnalyzers\Fixers\DefineDiagnosticDescriptorArgumentsCorrectlyFix.CustomFixAllProvider.cs (9)

41var diagnosticsToFix = new List<KeyValuePair<Project, ImmutableArray<Diagnostic>>>(); 47diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics)); 53Project project = fixAllContext.Project; 55diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics)); 61foreach (Project project in fixAllContext.Solution.Projects) 64diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(project, diagnostics)); 83private readonly List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> _diagnosticsToFix; 86public FixAllAdditionalDocumentChangeAction(FixAllScope fixAllScope, Solution solution, List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> diagnosticsToFix, string equivalenceKey) 103var project = kvp.Key;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixesAndRefactorings\FixAllHelper.cs (1)

15Project triggerProject)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ISolutionExtensions.cs (2)

38public static Project GetRequiredProject(this Solution solution, ProjectId projectId) 40var project = solution.GetProject(projectId);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (9)

17public static TLanguageService? GetLanguageService<TLanguageService>(this Project? project) where TLanguageService : class, ILanguageService 24public static TLanguageService GetRequiredLanguageService<TLanguageService>(this Project project) where TLanguageService : class, ILanguageService 33/// Gets extended host language services, which includes language services from <see cref="Project.LanguageServices"/>. 35public static HostLanguageServices GetExtendedLanguageServices(this Project project) 44public static string? TryGetAnalyzerConfigPathForProjectConfiguration(this Project project) 47public static string? TryGetAnalyzerConfigPathForDiagnosticConfiguration(this Project project, Diagnostic diagnostic) 53private static string? TryGetAnalyzerConfigPathForProjectOrDiagnosticConfiguration(Project project, Diagnostic? diagnostic) 101public static AnalyzerConfigDocument? TryGetExistingAnalyzerConfigDocumentAtPath(this Project project, string analyzerConfigPath) 109public static async Task<Compilation> GetRequiredCompilationAsync(this Project project, CancellationToken cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (2)

59foreach (var sourceProject in solution.Projects) 77var project = solution.GetProject(symbol.ContainingAssembly, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

25public Project Project => Document.Project;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

12public static bool CanApplyParseOptionChange(this Project project, ParseOptions oldOptions, ParseOptions newOptions)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixesAndRefactorings\FixAllHelper.cs (1)

15Project triggerProject)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ISolutionExtensions.cs (2)

38public static Project GetRequiredProject(this Solution solution, ProjectId projectId) 40var project = solution.GetProject(projectId);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (9)

17public static TLanguageService? GetLanguageService<TLanguageService>(this Project? project) where TLanguageService : class, ILanguageService 24public static TLanguageService GetRequiredLanguageService<TLanguageService>(this Project project) where TLanguageService : class, ILanguageService 33/// Gets extended host language services, which includes language services from <see cref="Project.LanguageServices"/>. 35public static HostLanguageServices GetExtendedLanguageServices(this Project project) 44public static string? TryGetAnalyzerConfigPathForProjectConfiguration(this Project project) 47public static string? TryGetAnalyzerConfigPathForDiagnosticConfiguration(this Project project, Diagnostic diagnostic) 53private static string? TryGetAnalyzerConfigPathForProjectOrDiagnosticConfiguration(Project project, Diagnostic? diagnostic) 101public static AnalyzerConfigDocument? TryGetExistingAnalyzerConfigDocumentAtPath(this Project project, string analyzerConfigPath) 109public static async Task<Compilation> GetRequiredCompilationAsync(this Project project, CancellationToken cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (2)

59foreach (var sourceProject in solution.Projects) 77var project = solution.GetProject(symbol.ContainingAssembly, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

25public Project Project => Document.Project;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

12public static bool CanApplyParseOptionChange(this Project project, ParseOptions oldOptions, ParseOptions newOptions)

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\TypeParameterSubstitution.cs (4)

20Project project, 34Compilation compilation, ISet<string> availableTypeParameterNames, Project project, CancellationToken cancellationToken) : AsyncSymbolVisitor 40private readonly Project _project = project; 124INamedTypeSymbol constraintType, IImmutableSet<Project> projects)

src\Analyzers\Core\CodeFixes\MatchFolderAndNamespace\AbstractChangeNamespaceToMatchFolderCodeFixProvider.CustomFixAllProvider.cs (1)

55foreach (var project in fixAllContext.Solution.Projects)

src\Analyzers\Core\CodeFixes\UpgradeProject\AbstractUpgradeProjectCodeFixProvider.cs (5)

22public abstract Solution UpgradeProject(Project project, string version); 23public abstract bool IsUpgrade(Project project, string newVersion); 43var project = context.Document.Project; 82var currentProject = currentSolution.GetRequiredProject(projectId); 93private bool CanUpgrade(Project project, string language, string version)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixesAndRefactorings\FixAllHelper.cs (1)

15Project triggerProject)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ISolutionExtensions.cs (2)

38public static Project GetRequiredProject(this Solution solution, ProjectId projectId) 40var project = solution.GetProject(projectId);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (9)

17public static TLanguageService? GetLanguageService<TLanguageService>(this Project? project) where TLanguageService : class, ILanguageService 24public static TLanguageService GetRequiredLanguageService<TLanguageService>(this Project project) where TLanguageService : class, ILanguageService 33/// Gets extended host language services, which includes language services from <see cref="Project.LanguageServices"/>. 35public static HostLanguageServices GetExtendedLanguageServices(this Project project) 44public static string? TryGetAnalyzerConfigPathForProjectConfiguration(this Project project) 47public static string? TryGetAnalyzerConfigPathForDiagnosticConfiguration(this Project project, Diagnostic diagnostic) 53private static string? TryGetAnalyzerConfigPathForProjectOrDiagnosticConfiguration(Project project, Diagnostic? diagnostic) 101public static AnalyzerConfigDocument? TryGetExistingAnalyzerConfigDocumentAtPath(this Project project, string analyzerConfigPath) 109public static async Task<Compilation> GetRequiredCompilationAsync(this Project project, CancellationToken cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (2)

59foreach (var sourceProject in solution.Projects) 77var project = solution.GetProject(symbol.ContainingAssembly, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

25public Project Project => Document.Project;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

12public static bool CanApplyParseOptionChange(this Project project, ParseOptions oldOptions, ParseOptions newOptions)

src\Analyzers\CSharp\CodeFixes\UpdateProjectToAllowUnsafe\CSharpUpdateProjectToAllowUnsafeCodeFixProvider.cs (1)

38private static Solution AllowUnsafeOnProject(Project project)

src\Analyzers\CSharp\CodeFixes\UpgradeProject\CSharpUpgradeProjectCodeFixProvider.cs (2)

87public override Solution UpgradeProject(Project project, string newVersion) 103public override bool IsUpgrade(Project project, string newVersion)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

39var project = document.Project;

src\Analyzers\CSharp\Tests\MatchFolderAndNamespace\CSharpMatchFolderAndNamespaceTests.cs (2)

73var project = solution.GetRequiredProject(projectId); 939var project = solution.GetRequiredProject(id);

RawStringLiteral\RawStringLiteralCommandHandler_Return.cs (1)

175var project = document.Project;

Completion\CompletionProviders\AbstractCSharpCompletionProviderTests.cs (1)

50internal override CompletionService GetCompletionService(Project project)

Completion\CompletionProviders\OverrideCompletionProviderTests.cs (4)

3474var p1 = workspace.CurrentSolution.Projects.First(p => p.Name == "P1"); 3475var updatedP1 = p1.AddMetadataReference(reference); 3521var project = workspace.CurrentSolution.Projects.Single(); 3522var updatedProject = project.AddMetadataReference(libRef);

Completion\CompletionServiceTests.cs (1)

206var project = SolutionUtilities.AddEmptyProject(workspace.CurrentSolution)

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (1)

764var project = workspace.CurrentSolution.Projects.Single();

EditAndContinue\ActiveStatementTrackingServiceTests.cs (1)

67var project = solution.Projects.Single();

ExtractMethod\ExtractMethodTests.cs (1)

10052var project = solution

Formatting\CodeCleanupTests.cs (2)

738var project = workspace.CurrentSolution.Projects.Single(); 849var project = solution.Projects.Single();

Formatting\CodeCleanupTests.TestFixers.cs (2)

93Project? project = null; 149Project? project = null;

Formatting\RazorLineFormattingOptionsTests.cs (1)

46var project = workspace.AddProject("Test", LanguageNames.CSharp);

NavigateTo\NavigateToSearcherTests.cs (19)

PdbSourceDocument\AbstractPdbSourceDocumentTests.cs (9)

101Project project, 121Project project, 172var mappedProject = provider.MapDocument(document); 187protected static Task<(Project, ISymbol)> CompileAndFindSymbolAsync( 202protected static async Task<(Project, ISymbol)> CompileAndFindSymbolAsync( 226var project = workspace.CurrentSolution.Projects.First(); 251protected static void CompileTestSource(string path, SourceText source, Project project, Location pdbLocation, Location sourceLocation, bool buildReferenceAssembly, bool windowsPdb, Encoding? fallbackEncoding = null) 259protected static void CompileTestSource(string dllFilePath, string sourceCodePath, string? pdbFilePath, string assemblyName, SourceText source, Project project, Location pdbLocation, Location sourceLocation, bool buildReferenceAssembly, bool windowsPdb, Encoding? fallbackEncoding = null) 264protected static void CompileTestSource(string dllFilePath, string[] sourceCodePaths, string? pdbFilePath, string assemblyName, SourceText[] sources, Project project, Location pdbLocation, Location sourceLocation, bool buildReferenceAssembly, bool windowsPdb, Encoding? fallbackEncoding = null)

PdbSourceDocument\ImplementationAssemblyLookupServiceTests.cs (7)

152var implProject = workspace.CurrentSolution.Projects.First(); 215var implProject = workspace.CurrentSolution.Projects.First(); 272var implProject = workspace.CurrentSolution.Projects.First(); 323var implProject = workspace.CurrentSolution.Projects.First(); 370var implProject = workspace.CurrentSolution.Projects.First(); 428var implProject = workspace.CurrentSolution.Projects.First(); 490var implProject = workspace.CurrentSolution.Projects.First();

PdbSourceDocument\NullResultMetadataAsSourceFileProvider.cs (2)

40public Task<MetadataAsSourceFile?> GetGeneratedFileAsync(MetadataAsSourceWorkspace metadataWorkspace, Workspace sourceWorkspace, Project sourceProject, ISymbol symbol, bool signaturesOnly, MetadataAsSourceOptions options, string tempPath, TelemetryMessage? telemetry, CancellationToken cancellationToken) 45public Project? MapDocument(Document document)

PdbSourceDocument\PdbSourceDocumentTests.cs (3)

395var implProject = workspace.CurrentSolution.Projects.First(); 436var implProject = workspace.CurrentSolution.Projects.First(); 836var project = workspace.CurrentSolution.Projects.First();

SymbolKey\SymbolKeyTests.cs (8)

44var project = solution.Projects.Single(); 79var project = solution.Projects.Single(); 118var project = solution.Projects.Single(); 164var project = solution.Projects.Single(); 196var bodyProject = solution.Projects.Single(p => p.AssemblyName == "BodyProject"); 197var referenceProject = solution.Projects.Single(p => p.AssemblyName == "ReferenceProject"); 254async Task<(Compilation bodyCompilation, Compilation referenceCompilation)> GetCompilationsAsync(Project bodyProject, Project referenceProject)

Workspaces\WorkspaceTests_EditorFeatures.cs (8)

Recommendations\RecommenderTests.cs (1)

63var project = solution.AddProject("test", "test", LanguageNames.CSharp);

CodeRefactorings\EnableNullable\EnableNullableCodeRefactoringProvider.cs (2)

61private static bool ShouldOfferRefactoring(Project project) 69Project project, CodeActionPurpose purpose, CancellationToken cancellationToken)

CodeRefactorings\EnableNullable\EnableNullableCodeRefactoringProvider.FixAllProvider.cs (1)

45var project = solution.GetRequiredProject(projectId);

GenerateType\CSharpGenerateTypeService.cs (1)

657internal override bool IsPublicOnlyAccessibility(ExpressionSyntax expression, Project project)

GoToDefinition\CSharpGoToDefinitionSymbolService.cs (1)

25protected override Task<ISymbol> FindRelatedExplicitlyDeclaredSymbolAsync(Project project, ISymbol symbol, CancellationToken cancellationToken)

ImplementInterface\AbstractChangeImplementationCodeRefactoringProvider.cs (3)

46protected abstract Task UpdateReferencesAsync(Project project, SolutionEditor solutionEditor, ISymbol implMember, INamedTypeSymbol containingType, CancellationToken cancellationToken); 65var project = document.Project; 212Project project, MemberImplementationMap implMemberToInterfaceMembers, CancellationToken cancellationToken)

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (1)

40Project project, SolutionEditor solutionEditor,

ImplementInterface\CSharpImplementImplicitlyCodeRefactoringProvider.cs (1)

45protected override Task UpdateReferencesAsync(Project project, SolutionEditor solutionEditor, ISymbol implMember, INamedTypeSymbol containingType, CancellationToken cancellationToken)

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider_Update.cs (1)

79var project = document.Project;

src\Analyzers\CSharp\CodeFixes\UpdateProjectToAllowUnsafe\CSharpUpdateProjectToAllowUnsafeCodeFixProvider.cs (1)

38private static Solution AllowUnsafeOnProject(Project project)

src\Analyzers\CSharp\CodeFixes\UpgradeProject\CSharpUpgradeProjectCodeFixProvider.cs (2)

87public override Solution UpgradeProject(Project project, string newVersion) 103public override bool IsUpgrade(Project project, string newVersion)

UseAutoProperty\CSharpUseAutoPropertyCodeFixProvider.cs (1)

91var project = propertyDocument.Project;

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (17)

EnableNullable\EnableNullableTests.cs (2)

29var project = solution.GetRequiredProject(projectId); 45var project = solution.GetRequiredProject(projectId);

src\Analyzers\CSharp\Tests\MatchFolderAndNamespace\CSharpMatchFolderAndNamespaceTests.cs (2)

73var project = solution.GetRequiredProject(projectId); 939var project = solution.GetRequiredProject(id);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

39var project = document.Project;

CodeGeneration\AddAttributesTests.cs (1)

27var emptyProject = ws.AddProject(

CodeGeneration\AddImportsTests.cs (3)

31var emptyProject = ws.AddProject( 852var emptyProject = ws.AddProject( 861var project = emptyProject

Formatting\FormattingMultipleSpanTests.cs (1)

153var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp);

Formatting\FormattingTreeEditTests.cs (1)

24var project = ws.AddProject("project", LanguageNames.CSharp);

OrganizeImports\OrganizeUsingsTests.cs (2)

29var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp); 79var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp);

EditorConfigSettings\DataProvider\Analyzer\AnalyzerSettingsProvider.cs (1)

34protected override void UpdateOptions(TieredAnalyzerConfigOptions options, ImmutableArray<Project> projectsInScope)

EditorConfigSettings\DataProvider\NamingStyles\NamingStyleSettingsProvider.cs (1)

26protected override void UpdateOptions(TieredAnalyzerConfigOptions options, ImmutableArray<Project> projectsInScope)

EditorConfigSettings\DataProvider\SettingsProviderBase.cs (2)

36protected abstract void UpdateOptions(TieredAnalyzerConfigOptions options, ImmutableArray<Project> projectsInScope); 56var project = projects.FirstOrDefault();

EditorConfigSettings\Extensions\SolutionExtensions.cs (4)

14public static ImmutableArray<Project> GetProjectsUnderEditorConfigFile(this Solution solution, string pathToEditorConfigFile) 24var builder = ArrayBuilder<Project>.GetInstance(); 25foreach (var project in solution.Projects) 41static bool TryGetFolderContainingProject(Project project, [NotNullWhen(true)] out DirectoryInfo? directoryInfo)

InlineDiagnostics\AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs (1)

104var project = document.Project;

InlineDiagnostics\InlineDiagnosticsTaggerProvider.cs (1)

64var project = workspace.CurrentSolution.GetProject(diagnostic.DocumentId.ProjectId);

IntelliSense\NavigationActionFactory.cs (1)

64var project = solution.GetRequiredProject(documentId.ProjectId);

Interactive\InteractiveSession.cs (3)

247var initProject = CreateSubmissionProjectNoLock(solution, initializationScriptProjectId, previousSubmissionProjectId: null, languageName, initializationScriptImports, initializationScriptReferences); 254var newSubmissionProject = CreateSubmissionProjectNoLock(solution, _currentSubmissionProjectId, _lastSuccessfulSubmissionProjectId, languageName, imports, references); 271private Project CreateSubmissionProjectNoLock(Solution solution, ProjectId newSubmissionProjectId, ProjectId? previousSubmissionProjectId, string languageName, ImmutableArray<string> imports, ImmutableArray<MetadataReference> references)

NavigateTo\NavigateToItemProvider.Callback.cs (1)

57var project = _solution.GetRequiredProject(result.NavigableItem.Document.Project.Id);

NavigateTo\NavigateToItemProvider.cs (1)

53foreach (var project in _workspace.CurrentSolution.Projects)

Navigation\AbstractDefinitionLocationService.cs (1)

130Project project, int position, ISymbol symbol, Document originalDocument, CancellationToken cancellationToken)

Peek\DefinitionPeekableItem.cs (1)

71var project = solution.GetProject(_peekableItem._projectId);

Peek\IPeekableItemFactory.cs (1)

23Task<IEnumerable<IPeekableItem>> GetPeekableItemsAsync(ISymbol symbol, Project project, IPeekResultFactory peekResultFactory, CancellationToken cancellationToken);

Peek\PeekableItemFactory.cs (2)

47Project project, 67var originatingProject = solution.GetProject(symbol.ContainingAssembly, cancellationToken);

Peek\PeekableItemSource.cs (1)

120IEnumerable<INavigableItem>? navigableItems, Project project,

Preview\AbstractPreviewFactoryService.cs (4)

89var oldProject = projectChanges.OldProject; 90var newProject = projectChanges.NewProject; 199foreach (var project in solutionChanges.GetAddedProjects()) 206foreach (var project in solutionChanges.GetRemovedProjects())

Preview\SolutionPreviewItem.cs (1)

15/// <param name="projectId"><see cref="ProjectId"/> for the <see cref="Project"/> that contains the content being visualized in the supplied <paramref name="lazyPreview"/></param>

Shared\Tagging\EventSources\TaggerEventSources.ParseOptionChangedEventSource.cs (2)

37var oldProject = e.OldSolution.GetRequiredProject(e.ProjectId); 38var newProject = e.NewSolution.GetRequiredProject(e.ProjectId);

SolutionEvents\HostLegacySolutionEventsWorkspaceEventListener.cs (1)

80var project = e.OldSolution.GetProject(projectId) ?? e.NewSolution.GetProject(projectId);

Suggestions\FixAll\FixMultipleOccurrencesService.cs (1)

46ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsToFix,

Completion\AbstractCompletionProviderTests.cs (1)

103internal virtual CompletionService GetCompletionService(Project project)

Diagnostics\GenerateType\GenerateTypeTestState.cs (2)

23public Project ProjectToBeModified { get; } 24public Project TriggeredProject { get; }

Diagnostics\GenerateType\TestGenerateTypeOptionsService.cs (2)

24public Project Project = null; 76Project project = null,

Diagnostics\GenerateType\TestProjectManagementService.cs (1)

29public string GetDefaultNamespace(Project project, Workspace workspace)

ObsoleteSymbol\AbstractObsoleteSymbolTests.cs (1)

27var project = workspace.CurrentSolution.Projects.Single();

ReassignedVariable\AbstractReassignedVariableTests.cs (1)

26var project = workspace.CurrentSolution.Projects.Single();

Utilities\GoToHelpers\MockSymbolNavigationService.vb (2)

19Public Function GetNavigableLocationAsync(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Task(Of INavigableLocation) Implements ISymbolNavigationService.GetNavigableLocationAsync 24Public Function TrySymbolNavigationNotifyAsync(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Task(Of Boolean) Implements ISymbolNavigationService.TrySymbolNavigationNotifyAsync

Utilities\MockSymbolNavigationServiceProvider.vb (4)

35Public TryNavigateToSymbolProvidedProject As Project 38Public TrySymbolNavigationNotifyProvidedProject As Project 46Public Function GetNavigableLocationAsync(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Task(Of INavigableLocation) Implements ISymbolNavigationService.GetNavigableLocationAsync 54project As Project,

CodeFixes\CodeFixServiceTests.cs (4)

57var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference); 278var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference); 365var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference); 748var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);

CodeGeneration\AbstractCodeGenerationTests.cs (1)

31var project = workspace.CurrentSolution

CodeRefactorings\CodeRefactoringServiceTest.cs (5)

49var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference); 108var project = workspace.CurrentSolution.Projects.Single(); 167var project = workspace.CurrentSolution.Projects.Single() 206var project = workspace.CurrentSolution.Projects.Single() 246var project = workspace.CurrentSolution.Projects.Single()

Completion\CompletionServiceTests.cs (1)

43var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);

Diagnostics\DiagnosticAnalyzerServiceTests.cs (14)

Diagnostics\DiagnosticDataTests.cs (1)

234var project = workspace.CurrentSolution.GetRequiredProject(documentId.ProjectId);

EditAndContinue\EditAndContinueLanguageServiceTests.cs (1)

126var project = solution.GetRequiredProject(projectId);

FindSymbols\SymbolTreeInfoTests.cs (4)

22var project = solution.Projects.Single(); 43var project = solution.Projects.Single(); 66var project = solution.Projects.Single(); 88var project = solution.Projects.Single();

MetadataAsSource\AbstractMetadataAsSourceTests.cs (2)

91var metadataProject = context.CurrentSolution 106var project = context.DefaultProject.AddMetadataReference(references[0]);

MetadataAsSource\AbstractMetadataAsSourceTests.TestContext.cs (4)

80public Project DefaultProject 85public Task<MetadataAsSourceFile> GenerateSourceAsync(ISymbol symbol, Project? project = null, bool signaturesOnly = true) 96Project? project = null, 150public async Task GenerateAndVerifySourceAsync(string symbolMetadataName, string expected, Project? project = null, bool signaturesOnly = true)

MetadataAsSource\MetadataAsSourceTests.cs (2)

1853var project = context.CurrentSolution.AddProject(projectId, "ProjectB", "ProjectB", LanguageNames.CSharp).GetRequiredProject(projectId) 1867var project = context.CurrentSolution.AddProject(projectId, "ProjectB", "ProjectB", LanguageNames.VisualBasic).GetRequiredProject(projectId)

Preview\PreviewWorkspaceTests.cs (5)

55var project = solution.AddProject("project", "project.dll", LanguageNames.CSharp); 69var project = solution.AddProject("project", "project.dll", LanguageNames.CSharp); 98var project = solution.AddProject("project", "project.dll", LanguageNames.CSharp); 133var project = previewWorkspace.CurrentSolution.AddProject("project", "project.dll", LanguageNames.CSharp); 166var project = previewWorkspace.CurrentSolution.Projects.Single();

SymbolFinder\SymbolFinderTests.cs (17)

SymbolKey\SymbolKeyCrossLanguageTests.cs (1)

51var vbProject = solution.Projects.Single(p => p.Language == LanguageNames.VisualBasic);

Compilation\CompilationTests.vb (1)

12Private Shared Function GetProject(snapshot As Solution, assemblyName As String) As Project

Diagnostics\DiagnosticServiceTests.vb (2)

1430project As Project, 2226Dim project = solution.Projects.Single(Function(p As Project) p.Name = "MainAssembly")

IntelliSense\CSharpCompletionCommandHandlerTests_DefaultsSource.vb (1)

687Friend Overrides Function ShouldTriggerCompletion(project As Project,

SyncNamespaces\SyncNamespacesServiceTests.vb (3)

183Dim project = projects.Single(Function(proj As Project) 244Dim project = projects.Single(Function(proj As Project) 249Dim project2 = projects.Single(Function(proj As Project)

Workspaces\TryFindSourceDefinitionTests.vb (1)

17Private Shared Function GetProject(snapshot As Solution, assemblyName As String) As Project

Internal\EmbeddedLanguages\AspNetCoreEmbeddedLanguageBraceMatcher.cs (1)

28Project project,

DebuggerFindReferencesService.cs (1)

27public async Task FindSymbolReferencesAsync(ISymbol symbol, Project project, CancellationToken cancellationToken)

Internal\NavigateTo\FSharpNavigateToSearchService.cs (2)

49ImmutableArray<Project> projects, 61foreach (var project in projects)

NavigateTo\IFSharpNavigateToSearchService.cs (1)

17Task<ImmutableArray<FSharpNavigateToSearchResult>> SearchProjectAsync(Project project, ImmutableArray<Document> priorityDocuments, string searchPattern, IImmutableSet<string> kinds, CancellationToken cancellationToken);

CodeActions\OmniSharpCodeFixContextFactory.cs (1)

35Project project,

NavigateTo\OmniSharpNavigateToSearchService.cs (2)

17public delegate Task OmniSharpNavigateToCallback(Project project, in OmniSharpNavigateToSearchResult result, CancellationToken cancellationToken); 43var project = solution.GetRequiredProject(result.NavigableItem.Document.Project.Id);

DocumentationComments\OmniSharpDocCommentConverter.cs (1)

14public static SyntaxNode ConvertToRegularComments(SyntaxNode node, Project project, CancellationToken cancellationToken)

Cohost\Handlers\Diagnostics.cs (1)

27var project = document.Project;

Cohost\IRazorSemanticTokensRefreshQueue.cs (1)

22Task TryEnqueueRefreshComputationAsync(Project project, CancellationToken cancellationToken);

Cohost\RazorSemanticTokensRefreshQueueWrapper.cs (1)

41public Task TryEnqueueRefreshComputationAsync(Project project, CancellationToken cancellationToken)

RazorProjectExtensions.cs (2)

15internal static ValueTask<GeneratorDriverRunResult?> GetSourceGeneratorRunResultAsync(this Project project, CancellationToken cancellationToken) 20internal static async ValueTask<IEnumerable<SourceGeneratedDocument>> GetSourceGeneratedDocumentsForGeneratorAsync(this Project project, string assemblyName, string assemblyPath, Version assemblyVersion, string typeName, CancellationToken cancellationToken)

External\IDescriptionService.cs (1)

20Task<IEnumerable<TaggedText>> GetDescriptionAsync(ISymbol symbol, Project project, CancellationToken cancellationToken);

External\ILocationService.cs (1)

19Task<FileLinePositionSpan[]> GetSymbolLocationsAsync(ISymbol symbol, Project project, CancellationToken cancellationToken);

Internal\DescriptionService.cs (1)

34public async Task<IEnumerable<TaggedText>> GetDescriptionAsync(ISymbol symbol, Project project, CancellationToken cancellationToken)

Internal\LocationService.cs (1)

45public async Task<FileLinePositionSpan[]> GetSymbolLocationsAsync(ISymbol symbol, Project project, CancellationToken cancellationToken)

Internal\XamlDiagnosticSource.cs (1)

20Project IDiagnosticSource.GetProject() => document.Project;

AddImport\AbstractAddImportFeatureService.cs (16)

144var project = document.Project; 145var projectToAssembly = new ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>>(concurrencyLevel: 2, capacity: project.Solution.ProjectIds.Count); 166private static bool IsHostOrRemoteWorkspace(Project project) 170ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>> projectToAssembly, 172Project project, 215ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>> projectToAssembly, 216Project project, ConcurrentQueue<Reference> allSymbolReferences, int maxResults, 261Project project, ConcurrentQueue<Reference> allSymbolReferences, int maxResults, SymbolReferenceFinder finder, 321private static ImmutableArray<(Project, PortableExecutableReference)> GetUnreferencedMetadataReferences( 322Project project, HashSet<PortableExecutableReference> seenReferences) 324using var _ = ArrayBuilder<(Project, PortableExecutableReference)>.GetInstance(out var result); 327foreach (var p in solution.Projects) 428private static Compilation CreateCompilation(Project project, PortableExecutableReference reference) 454private static HashSet<Project> GetViableUnreferencedProjects(Project project) 457var viableProjects = new HashSet<Project>(solution.Projects.Where(p => p.SupportsCompilation));

AddImport\AddImportFixData.cs (2)

64/// The optional id for a <see cref="Project"/> we'd like to add a reference to. 75/// is the id for the <see cref="Project"/> we can find that <see cref="PortableExecutableReference"/>

AddImport\CodeActions\AssemblyReferenceCodeAction.cs (4)

42var newProject = newDocument.Project; 64Project newProject) : CodeActionOperation 68private readonly Project _newProject = newProject; 99var newProject = _newProject.WithMetadataReferences(

AddImport\CodeActions\MetadataSymbolReferenceCodeAction.cs (2)

27protected override Task<CodeActionOperation?> UpdateProjectAsync(Project project, bool isPreview, CancellationToken cancellationToken) 29var projectWithReference = project.Solution.GetRequiredProject(FixData.PortableExecutableReferenceProjectId);

AddImport\CodeActions\ProjectSymbolReferenceCodeAction.cs (2)

40protected override Task<CodeActionOperation?> UpdateProjectAsync(Project project, bool isPreview, CancellationToken cancellationToken) 45var projectWithAddedReference = project.AddProjectReference(new ProjectReference(FixData.ProjectReferenceToAdd));

AddImport\CodeActions\SymbolReference.SymbolReferenceCodeAction.cs (1)

61protected abstract Task<CodeActionOperation?> UpdateProjectAsync(Project project, bool isPreview, CancellationToken cancellationToken);

AddImport\References\ProjectSymbolReference.cs (3)

30Project project) : SymbolReference(provider, symbolResult) 32private readonly Project _project = project; 92var project = document.Project;

AddImport\SearchScopes\AllSymbolsProjectSearchScope.cs (1)

21Project project,

AddImport\SearchScopes\MetadataSymbolsSearchScope.cs (2)

17Project assemblyProject, 22private readonly Project _assemblyProject = assemblyProject;

AddImport\SearchScopes\ProjectSearchScope.cs (2)

11protected readonly Project _project; 15Project project,

AddImport\SearchScopes\SourceSymbolsProjectSearchScope.cs (4)

24ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol?>> projectToAssembly, 25Project project, bool ignoreCase) : ProjectSearchScope(provider, project, ignoreCase) 27private readonly ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol?>> _projectToAssembly = projectToAssembly; 50static AsyncLazy<IAssemblySymbol?> CreateLazyAssembly(Project project)

AddImport\SymbolReferenceFinder.cs (3)

99internal Task<ImmutableArray<SymbolReference>> FindInSourceSymbolsInProjectAsync(ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>> projectToAssembly, Project project, bool exact, CancellationToken cancellationToken) 102internal Task<ImmutableArray<SymbolReference>> FindInMetadataSymbolsAsync(IAssemblySymbol assembly, Project assemblyProject, PortableExecutableReference metadataReference, bool exact, CancellationToken cancellationToken)

AddImport\SymbolReferenceFinder_PackageAssemblySearch.cs (2)

139var project = _document.Project; 184Project project,

AddMissingReference\AddMissingReferenceCodeAction.cs (4)

15internal sealed class AddMissingReferenceCodeAction(Project project, string title, ProjectReference? projectReferenceToAdd, AssemblyIdentity missingAssemblyIdentity) : CodeAction 17private readonly Project _project = project; 29public static async Task<CodeAction> CreateAsync(Project project, AssemblyIdentity missingAssemblyIdentity, CancellationToken cancellationToken) 52var candidateProject = project.Solution.GetRequiredProject(candidateProjectId);

BraceMatching\IEmbeddedLanguageBraceMatcher.cs (1)

13Project project,

ChangeSignature\DelegateInvokeMethodReferenceFinder.cs (2)

53foreach (var project in solution.Projects) 70Project project,

CodeFixes\Configuration\ConfigurationUpdater.cs (14)

70private readonly Project _project; 82Project project, 110Project project, 129Project project, 160Project project, 174Project project, 183Project project, 202Project project, 213Project project, 231var currentProject = project; 307var project = currentSolution.GetProject(projectId); 322private static AnalyzerConfigDocument? GetOrCreateAnalyzerConfigDocument(Project project, string analyzerConfigPath) 342Project project) 383internal static ImmutableArray<IOption2> GetCodeStyleOptionsForDiagnostic(Diagnostic diagnostic, Project project)

CodeFixes\Configuration\ConfigureCodeStyle\ConfigureCodeStyleOptionCodeFixProvider.cs (2)

58public Task<ImmutableArray<CodeFix>> GetFixesAsync(Project project, IEnumerable<Diagnostic> diagnostics, CancellationToken cancellationToken) 61private static ImmutableArray<CodeFix> GetConfigurations(Project project, IEnumerable<Diagnostic> diagnostics)

CodeFixes\Configuration\ConfigureSeverity\ConfigureSeverityLevelCodeFixProvider.cs (2)

50public Task<ImmutableArray<CodeFix>> GetFixesAsync(Project project, IEnumerable<Diagnostic> diagnostics, CancellationToken cancellationToken) 53private static ImmutableArray<CodeFix> GetConfigurations(Project project, IEnumerable<Diagnostic> diagnostics, CancellationToken cancellationToken)

CodeFixes\FixAllOccurrences\IFixMultipleOccurrencesService.cs (1)

35ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsToFix,

CodeFixes\Service\CodeFixService.FixAllDiagnosticProvider.cs (2)

66public override async Task<IEnumerable<Diagnostic>> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) 75public override async Task<IEnumerable<Diagnostic>> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken)

CodeFixes\Service\CodeFixService.FixAllPredefinedDiagnosticProvider.cs (2)

22public override Task<IEnumerable<Diagnostic>> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) 28public override Task<IEnumerable<Diagnostic>> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken)

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (2)

135ImmutableDictionary<Project, ImmutableArray<Diagnostic>> projectsAndDiagnosticsToFixMap, 200Project project, ImmutableArray<Diagnostic> diagnostics,

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.AbstractGlobalSuppressMessageCodeAction.cs (2)

25private readonly Project _project; 27protected AbstractGlobalSuppressMessageCodeAction(AbstractSuppressionCodeFixProvider fixer, Project project)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (2)

169Project project, IEnumerable<Diagnostic> diagnostics, CancellationToken cancellationToken) 185Document documentOpt, Project project, IEnumerable<Diagnostic> diagnostics, SuppressionTargetInfo suppressionTargetInfo, bool skipSuppressMessage, bool skipUnsuppress, CancellationToken cancellationToken)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageCodeAction.cs (1)

17Project project, Diagnostic diagnostic,

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs (9)

34Project project) 48internal static CodeAction Create(string title, AbstractSuppressionCodeFixProvider fixer, Project triggerProject, ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsByProject) 76var oldProject = grouping.Key; 77var currentProject = currentSolution.GetProject(oldProject.Id); 98Project triggerProject, 99ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsByProject, 105var currentProject = currentSolution.GetProject(oldProject.Id); 173private static async Task<IEnumerable<KeyValuePair<ISymbol, ImmutableArray<Diagnostic>>>> CreateDiagnosticsBySymbolAsync(Project project, ImmutableArray<Diagnostic> diagnostics, CancellationToken cancellationToken)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.BatchFixer.cs (1)

85Project project, ImmutableArray<Diagnostic> diagnostics,

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.cs (1)

26Project project,

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Attribute.cs (3)

23private readonly Project _project; 28Project project, 37Project project,

CodeRefactorings\MoveType\AbstractMoveTypeService.MoveTypeEditor.cs (2)

50var projectToBeUpdated = SemanticDocument.Project; 120var projectToBeUpdated = document.Project;

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.MoveFileCodeAction.cs (1)

159public static FolderInfo CreateFolderHierarchyForProject(Project project)

Common\AbstractProjectExtensionProvider.cs (1)

47public static ImmutableArray<TExtension> GetExtensions(Project? project)

Completion\CompletionService.cs (6)

127/// We pass the project here to retrieve information about the <see cref="Project.AnalyzerReferences"/>, 128/// <see cref="WorkspaceKind"/> and <see cref="Project.Language"/> which are fast operations. 132Project? project, 390internal void TriggerLoadProjectProviders(Project project, CompletionOptions options) 393internal CompletionProvider? GetProvider(CompletionItem item, Project? project) 406public ImmutableArray<CompletionProvider> GetProjectProviders(Project project)

Completion\CompletionService.ProviderManager.cs (4)

97public ImmutableArray<CompletionProvider> GetCachedProjectCompletionProvidersOrQueueLoadInBackground(Project? project, CompletionOptions options) 152public CompletionProvider? GetProvider(CompletionItem item, Project? project) 168Project? project, ImmutableHashSet<string>? roles, CompletionTrigger trigger, in CompletionOptions options) 289public ImmutableArray<CompletionProvider> GetProjectProviders(Project project)

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (6)

135var currentProject = context.Document.Project; 137foreach (var project in context.Document.Project.Solution.Projects) 171private static bool IsProjectTypeUnsupported(Project project) 179var project = completionContext.Document.Project; 272var project = document.Project.Solution.GetRequiredProject(projectId); 284private static async Task<string> GetPublicKeyOfProjectAsync(Project project, CancellationToken cancellationToken)

Completion\Providers\CompletionUtilities.cs (3)

28public static ImmutableArray<Project> GetDistinctProjectsFromLatestSolutionSnapshot(ImmutableSegmentedList<Project> projects) 38foreach (var project in projects)

Completion\Providers\ImportCompletionProvider\AbstractImportCompletionCacheServiceFactory.cs (5)

18Func<ImmutableSegmentedList<Project>, CancellationToken, ValueTask> processBatchAsync, 25private readonly Func<ImmutableSegmentedList<Project>, CancellationToken, ValueTask> _processBatchAsync = processBatchAsync; 30var workQueue = new AsyncBatchingWorkQueue<Project>( 40AsyncBatchingWorkQueue<Project> workQueue) : IImportCompletionCacheService<TProjectCacheEntry, TMetadataCacheEntry> 42public AsyncBatchingWorkQueue<Project> WorkQueue { get; } = workQueue;

Completion\Providers\ImportCompletionProvider\AbstractTypeImportCompletionService.cs (8)

43public void QueueCacheWarmUpTask(Project project) 54var currentProject = syntaxContext.Document.Project; 83private async Task<(ImmutableArray<TypeImportCompletionCacheEntry> results, bool isPartial)> GetCacheEntriesAsync(Project currentProject, Compilation originCompilation, bool forceCacheCreation, CancellationToken cancellationToken) 89using var _2 = ArrayBuilder<Project>.GetInstance(out var projectsBuilder); 100foreach (var project in projectsBuilder) 157public static async ValueTask BatchUpdateCacheAsync(ImmutableSegmentedList<Project> projects, CancellationToken cancellationToken) 160foreach (var project in latestProjects) 177private async Task<TypeImportCompletionCacheEntry> GetUpToDateCacheForProjectAsync(Project project, CancellationToken cancellationToken)

Completion\Providers\ImportCompletionProvider\ExtensionMethodImportCompletionHelper.cs (6)

35public static async Task WarmUpCacheAsync(Project project, CancellationToken cancellationToken) 52public static void WarmUpCacheInCurrentProcess(Project project) 66var project = document.Project; 117public static async ValueTask BatchUpdateCacheAsync(ImmutableSegmentedList<Project> projects, CancellationToken cancellationToken) 120foreach (var project in latestProjects) 233Project project,

Completion\Providers\ImportCompletionProvider\ExtensionMethodImportCompletionHelper.SymbolComputer.cs (8)

59private static IImportCompletionCacheService<ExtensionMethodImportCompletionCacheEntry, object> GetCacheService(Project project) 65public static void QueueCacheWarmUpTask(Project project) 70public static async ValueTask UpdateCacheAsync(Project project, CancellationToken cancellationToken) 74foreach (var relevantProject in GetAllRelevantProjects(project)) 124private static ImmutableArray<Project> GetAllRelevantProjects(Project project) 132private static ImmutableArray<PortableExecutableReference> GetAllRelevantPeReferences(Project project) 136Project project,

Completion\Providers\ImportCompletionProvider\IImportCompletionCacheService.cs (1)

12AsyncBatchingWorkQueue<Project> WorkQueue { get; }

Completion\Providers\ImportCompletionProvider\ITypeImportCompletionService.cs (1)

30void QueueCacheWarmUpTask(Project project);

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (6)

340var project = group.Key; 436Project startingProject, INamedTypeSymbol tupleType, CancellationToken cancellationToken) 461var allProjects = dependentProjects.Select<ProjectId, Project>(solution.GetRequiredProject) 468foreach (var project in allProjects) 478Project project, INamedTypeSymbol tupleType, CancellationToken cancellationToken) 489private static async Task AddDocumentsToUpdateForProjectAsync(Project project, ArrayBuilder<DocumentToUpdate> result, ImmutableArray<string> tupleFieldNames, CancellationToken cancellationToken)

DesignerAttribute\DesignerAttributeDiscoveryService.cs (7)

62private static async ValueTask<bool> HasDesignerCategoryTypeAsync(Project project, CancellationToken cancellationToken) 136var frozenProject = frozenDocument.Project; 177Project project, 197Project project, 221Project project, 267Project project, DocumentId documentId, string filePath, bool hasDesignerCategoryType, string? existingCategory) 285bool hasDesignerCategoryType, Project project, DocumentId documentId, string? existingCategory, CancellationToken cancellationToken)

Diagnostics\CodeAnalysisDiagnosticAnalyzerService.cs (1)

85public async ValueTask RunAnalysisAsync(Project project, CancellationToken cancellationToken)

Diagnostics\ICodeAnalysisDiagnosticAnalyzerService.cs (4)

22ValueTask RunAnalysisAsync(Project project, CancellationToken cancellationToken); 25/// Returns true if <see cref="RunAnalysisAsync(Project, CancellationToken)"/> was invoked on either the current or 35/// cref="RunAnalysisAsync(Project, CancellationToken)"/> invocation on the containing project or solution. The 45/// from the last <see cref="RunAnalysisAsync(Project, CancellationToken)"/> invocation on the given project or

Diagnostics\IDiagnosticAnalyzerService.cs (3)

33Task<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectAsync(Project project, CancellationToken cancellationToken); 56Task<ImmutableArray<DiagnosticData>> GetDiagnosticsForIdsAsync(Project project, DocumentId? documentId, ImmutableHashSet<string>? diagnosticIds, Func<DiagnosticAnalyzer, bool>? shouldIncludeAnalyzer, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken); 73Task<ImmutableArray<DiagnosticData>> GetProjectDiagnosticsForIdsAsync(Project project, ImmutableHashSet<string>? diagnosticIds, Func<DiagnosticAnalyzer, bool>? shouldIncludeAnalyzer, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken);

Diagnostics\Service\DiagnosticAnalyzerService.cs (5)

80public static Task<VersionStamp> GetDiagnosticVersionAsync(Project project, CancellationToken cancellationToken) 117public Task<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectAsync(Project project, CancellationToken cancellationToken) 121Project project, DocumentId? documentId, ImmutableHashSet<string>? diagnosticIds, Func<DiagnosticAnalyzer, bool>? shouldIncludeAnalyzer, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) 127Project project, ImmutableHashSet<string>? diagnosticIds, 139public Task<ImmutableArray<DiagnosticAnalyzer>> GetAnalyzersAsync(Project project, CancellationToken cancellationToken)

Diagnostics\Service\DocumentAnalysisExecutor_Helpers.cs (2)

52public static bool IsAnalyzerEnabledForProject(DiagnosticAnalyzer analyzer, Project project, IGlobalOptionService globalOptions) 125private static async Task VerifyDiagnosticLocationsAsync(ImmutableArray<Diagnostic> diagnostics, Project project, CancellationToken cancellationToken)

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.CompilationManager.cs (1)

29Project project,

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.cs (2)

48public Task<ImmutableArray<DiagnosticAnalyzer>> GetAnalyzersForTestingPurposesOnlyAsync(Project project, CancellationToken cancellationToken) 51private static string GetProjectLogMessage(Project project, ImmutableArray<DocumentDiagnosticAnalyzer> analyzers)

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.Executor.cs (1)

29Project project,

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.StateManager.cs (1)

44/// Return <see cref="DiagnosticAnalyzer"/>s for the given <see cref="Project"/>.

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnostics.cs (4)

21public Task<ImmutableArray<DiagnosticData>> GetDiagnosticsForIdsAsync(Project project, DocumentId? documentId, ImmutableHashSet<string>? diagnosticIds, Func<DiagnosticAnalyzer, bool>? shouldIncludeAnalyzer, bool includeLocalDocumentDiagnostics, bool includeNonLocalDocumentDiagnostics, CancellationToken cancellationToken) 36Project project, 52Project project, 138bool ShouldIncludeAnalyzer(Project project, DiagnosticAnalyzer analyzer)

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs (1)

61var project = document.Project;

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_IncrementalAnalyzer.cs (2)

38public async Task<ImmutableArray<DiagnosticData>> ForceAnalyzeProjectAsync(Project project, CancellationToken cancellationToken) 96DiagnosticAnalyzerInfoCache infoCache, DiagnosticAnalyzer analyzer, bool isHostAnalyzer, Project project)

Diagnostics\Service\EngineV2\InProcOrRemoteHostAnalyzerRunner.cs (6)

45Project project, 54Project project, 82Project project, 125Project project, 159Project project, 215private static ImmutableDictionary<DocumentId, ImmutableArray<DiagnosticData>> Hydrate(ImmutableArray<(DocumentId documentId, ImmutableArray<DiagnosticData> diagnostics)> diagnosticByDocument, Project project)

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (5)

506Project oldProject, 507Project newProject, 724private static async ValueTask<(Document? document, SourceText text)> GetDocumentContentAsync(Project project, DocumentId documentId, CancellationToken cancellationToken) 768private static async ValueTask<DocumentSemanticModel> GetDocumentSemanticModelAsync(Project project, Document? document, SyntaxTree tree, CancellationToken cancellationToken) 2560Project oldProject,

EditAndContinue\CommittedSolution.cs (4)

139public Project? GetProject(ProjectId id) 142public Project GetRequiredProject(ProjectId id) 381IEnumerable<(Project, IEnumerable<CodeAnalysis.DocumentState>)> documentsByProject, 382Func<Project, CompilationOutputs> compilationOutputsProvider,

EditAndContinue\DebuggingSession.cs (10)

33private readonly Func<Project, CompilationOutputs> _compilationOutputsProvider; 132Func<Project, CompilationOutputs> compilationOutputsProvider, 257internal CompilationOutputs GetCompilationOutputs(Project project) 275internal Task<(Guid Mvid, Diagnostic? Error)> GetProjectModuleIdAsync(Project project, CancellationToken cancellationToken) 310Project baselineProject, 451var project = document.Project; 768var oldProject = LastCommittedSolution.GetProject(projectId); 775var newProject = solution.GetRequiredProject(projectId); 885var newProject = mappedDocument.Project; 887var oldProject = LastCommittedSolution.GetProject(newProject.Id);

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (5)

27private readonly Dictionary<DocumentId, (AsyncLazy<DocumentAnalysisResults> results, Project oldProject, Document? newDocument, ImmutableArray<ActiveStatementLineSpan> activeStatementSpans)> _analyses = []; 84var oldProject = oldDocument?.Project ?? oldSolution.GetRequiredProject(newDocument!.Project.Id); 85var newProject = newDocument?.Project ?? newSolution.GetRequiredProject(oldProject.Id); 175private AsyncLazy<DocumentAnalysisResults> GetDocumentAnalysisNoLock(Project oldProject, Project newProject, Document? oldDocument, Document? newDocument, ImmutableArray<ActiveStatementLineSpan> activeStatementSpans)

EditAndContinue\EditAndContinueService.cs (4)

53private Func<Project, CompilationOutputs> _compilationOutputsProvider = GetCompilationOutputs; 102private static CompilationOutputs GetCompilationOutputs(Project project) 183private static IEnumerable<(Project, IEnumerable<DocumentState>)> GetDocumentStatesGroupedByProject(Solution solution, ImmutableArray<DocumentId> documentIds) 289public void SetOutputProvider(Func<Project, CompilationOutputs> value)

EditAndContinue\EditSession.cs (21)

155public async Task<string?> ReportModuleDiagnosticsAsync(Guid mvid, Project oldProject, Project newProject, ImmutableArray<DocumentAnalysisResults> documentAnalyses, ArrayBuilder<Diagnostic> diagnostics, CancellationToken cancellationToken) 176private static async IAsyncEnumerable<Location> CreateChangedLocationsAsync(Project oldProject, Project newProject, ImmutableArray<DocumentAnalysisResults> documentAnalyses, [EnumeratorCancellation] CancellationToken cancellationToken) 286foreach (var newProject in newSolution.Projects) 293var oldProject = oldSolution.GetProject(newProject.Id); 301foreach (var oldProject in oldSolution.Projects) 308var newProject = newSolution.GetProject(oldProject.Id); 335internal static async ValueTask<bool> HasDocumentDifferencesAsync(Project oldProject, Project newProject, ProjectDocumentDifferences? documentDifferences, CancellationToken cancellationToken) 437internal static async Task GetDocumentDifferencesAsync(TraceLog log, Project oldProject, Project newProject, ProjectDocumentDifferences documentDifferences, ArrayBuilder<Diagnostic> diagnostics, CancellationToken cancellationToken) 486private static async ValueTask<TextDocumentStates<SourceGeneratedDocumentState>> GetSourceGeneratedDocumentStatesAsync(TraceLog log, Project project, ArrayBuilder<Diagnostic>? diagnostics, CancellationToken cancellationToken) 506internal static async IAsyncEnumerable<DocumentId> GetChangedDocumentsAsync(TraceLog log, Project oldProject, Project newProject, [EnumeratorCancellation] CancellationToken cancellationToken) 650Project oldProject, 651Project newProject, 884foreach (var newProject in solution.Projects) 893var oldProject = oldSolution.GetProject(newProject.Id); 1272private async ValueTask LogDeltaFilesAsync(TraceLog.FileLogger log, ManagedHotReloadUpdate delta, int baselineGeneration, Project oldProject, Project newProject, CancellationToken cancellationToken)

EditAndContinue\EmitSolutionUpdateResults.cs (1)

79var firstProject = solution.GetProject(runningProjects.FirstOrDefault().Key) ?? solution.Projects.First();

EditAndContinue\IEditAndContinueAnalyzer.cs (2)

18Project oldProject, 19Project newProject,

EditAndContinue\ProjectDiagnostics.cs (1)

22var project = solution.GetRequiredProject(projectId);

EditAndContinue\Utilities\Extensions.cs (2)

43public static bool SupportsEditAndContinue(this Project project, TraceLog? log = null) 75public static string GetLogDisplay(this Project project)

EmbeddedLanguages\Classification\AbstractEmbeddedLanguageClassificationService.cs (4)

41var project = document.Project; 52SolutionServices services, Project? project, SemanticModel semanticModel, ImmutableArray<TextSpan> textSpans, ClassificationOptions options, SegmentedList<ClassifiedSpan> result, CancellationToken cancellationToken) 68Project project, 77private readonly Project _project = project;

EmbeddedLanguages\Classification\EmbeddedLanguageClassifierContext.cs (2)

24public Project Project { get; } 43Project project,

EmbeddedLanguages\Json\LanguageServices\JsonBraceMatcher.cs (1)

36Project project,

EmbeddedLanguages\RegularExpressions\LanguageServices\RegexBraceMatcher.cs (1)

39Project project,

ExternalAccess\UnitTesting\API\INewUnitTestingIncrementalAnalyzerImplementation.cs (1)

18Project project,

ExternalAccess\UnitTesting\API\NewUnitTestingIncrementalAnalyzer.cs (1)

29Project project,

ExternalAccess\UnitTesting\API\UnitTestingSearchHelpers.cs (5)

26Project project, UnitTestingSearchQuery query, CancellationToken cancellationToken) 49Project project, UnitTestingSearchQuery query, CancellationToken cancellationToken) 141Project project, 153Project project, 166Project project,

ExternalAccess\UnitTesting\SolutionCrawler\IUnitTestingIncrementalAnalyzer.cs (1)

19Project project,

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.cs (20)

226foreach (var addedProject in solutionChanges.GetAddedProjects()) 236foreach (var removedProject in solutionChanges.GetRemovedProjects()) 260var oldProject = oldSolution.GetRequiredProject(projectId); 261var newProject = newSolution.GetRequiredProject(projectId); 278var project = solution.GetRequiredProject(documentId.ProjectId); 289var oldProject = oldSolution.GetRequiredProject(documentId.ProjectId); 290var newProject = newSolution.GetRequiredProject(documentId.ProjectId); 329private async Task EnqueueDocumentWorkItemAsync(Project project, DocumentId documentId, TextDocument? document, UnitTestingInvocationReasons invocationReasons, SyntaxNode? changedMember = null) 354private static Document GetRequiredDocument(Project project, DocumentId documentId, Document? document) 369private async Task EnqueueFullProjectWorkItemAsync(Project project, UnitTestingInvocationReasons invocationReasons) 397IUnitTestingIncrementalAnalyzer analyzer, Project project, DocumentId documentId, Document? document, UnitTestingInvocationReasons invocationReasons) 427var oldProject = projectChanges.OldProject; 428var newProject = projectChanges.NewProject; 497foreach (var project in solution.Projects) 568var project = solution.GetProject(projectId); 616var project = solution.GetProject(projectId); 634public IEnumerable<(Project project, DocumentId documentId)> GetDocumentIds(Solution solution) 643foreach (var project in solution.Projects) 660var project = solution.GetProject(projectId); 671var project = solution.GetProject(documentId.ProjectId);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingLowPriorityProcessor.cs (1)

133var project = processingSolution.GetProject(projectId);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingSemanticChangeProcessor.cs (8)

209private void EnqueueFullProjectDependency(Project project, IAssemblySymbol? internalVisibleToAssembly = null) 226var otherProject = solution.GetProject(projectId); 243public void Enqueue(Project project, DocumentId documentId, Document? document, SyntaxPath? changedMember) 308private readonly struct UnitTestingData(Project project, DocumentId documentId, Document? document, SyntaxPath? changedMember, IAsyncToken asyncToken) 313public readonly Project Project = project; 382public async Task EnqueueWorkItemAsync(Project project, DocumentId documentId, Document? document) 405var project = _registration.GetSolutionToAnalyze().GetProject(data.ProjectId); 430private async Task EnqueueWorkItemAsync(Project? project)

ExternalAccess\VSTypeScript\Api\IVSTypeScriptNavigateToSearchService.cs (1)

16Task<ImmutableArray<IVSTypeScriptNavigateToSearchResult>> SearchProjectAsync(Project project, ImmutableArray<Document> priorityDocuments, string searchPattern, IImmutableSet<string> kinds, CancellationToken cancellationToken);

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (4)

51ImmutableArray<Project> projects, 63using var _ = PooledHashSet<Project>.GetInstance(out var processedProjects); 68foreach (var project in projects) 73async Task ProcessProjectAsync(Project project)

ExternalAccess\Watch\Api\WatchHotReloadService.cs (1)

186public static string? GetTargetFramework(Project project)

FindUsages\AbstractFindUsagesService_FindImplementations.cs (2)

42IFindUsagesContext context, ISymbol symbol, Project project, OptionsProvider<ClassificationOptions> classificationOptions, CancellationToken cancellationToken) 69ISymbol symbol, Project project, IFindUsagesContext context, OptionsProvider<ClassificationOptions> classificationOptions, CancellationToken cancellationToken)

FindUsages\AbstractFindUsagesService_FindReferences.cs (3)

108IFindUsagesContext context, ISymbol symbol, Project project, OptionsProvider<ClassificationOptions> classificationOptions, CancellationToken cancellationToken) 127Project project, 159Project project,

FindUsages\DefinitionItem.DefaultDefinitionItem.cs (2)

60private async ValueTask<(Project? project, ISymbol? symbol)> TryResolveSymbolAsync(Solution solution, string symbolKey, CancellationToken cancellationToken) 68var project = solution.GetProject(ProjectId.CreateFromSerialized(Guid.Parse(projectIdGuid), projectDebugName));

FindUsages\FindUsagesHelpers.cs (2)

22public static Task<(ISymbol symbol, Project project)?> GetRelevantSymbolAndProjectAtPositionAsync( 35public static async Task<(ISymbol symbol, Project project)?> GetRelevantSymbolAndProjectAtPositionAsync(

FullyQualify\AbstractFullyQualifyService.cs (1)

62var project = document.Project;

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (1)

40var project = _document.Project;

GenerateType\AbstractGenerateTypeService.CodeAction.cs (1)

116private bool IsPublicOnlyAccessibility(State state, Project project)

GenerateType\AbstractGenerateTypeService.cs (1)

52internal abstract bool IsPublicOnlyAccessibility(TExpressionSyntax expression, Project project);

GenerateType\AbstractGenerateTypeService.Editor.cs (11)

178private string GetNamespaceToGenerateIntoForUsageWithNamespace(Project targetProject, Project triggeringProject) 266Project projectToBeUpdated, 267Project triggeringProject, 337Project projectToBeUpdated, 338Project triggeringProject, 372private static Solution AddProjectReference(Project projectToBeUpdated, Project triggeringProject, Solution updatedSolution) 404Project triggeringProject, 468Project targetProject, 469Project triggeringProject)

GenerateType\GenerateTypeOptionsResult.cs (2)

21public Project Project { get; } 32Project project,

GoToDefinition\AbstractGoToDefinitionSymbolService.cs (3)

18protected abstract Task<ISymbol> FindRelatedExplicitlyDeclaredSymbolAsync(Project project, ISymbol symbol, CancellationToken cancellationToken); 22public async Task<(ISymbol? symbol, Project project, TextSpan boundSpan)> GetSymbolProjectAndBoundSpanAsync( 25var project = document.Project;

GoToDefinition\IGoToDefinitionSymbolService.cs (1)

14Task<(ISymbol? symbol, Project project, TextSpan boundSpan)> GetSymbolProjectAndBoundSpanAsync(

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (3)

44Project project, 76private async ValueTask<(Project remapped, SymbolAndLineNumberArray symbolAndLineNumbers)> GetMemberSymbolsAsync( 91Project? project = null;

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (4)

65Project sourceProject, 334public Project? MapDocument(Document document) 345var project = solution.GetProject(fileInfo.SourceProjectId); 366private static async Task<UniqueDocumentKey> GetUniqueDocumentKeyAsync(Project project, INamedTypeSymbol topLevelNamedType, bool signaturesOnly, CancellationToken cancellationToken)

MetadataAsSource\IMetadataAsSourceFileProvider.cs (2)

22Project sourceProject, 56Project? MapDocument(Document document);

MetadataAsSource\IMetadataAsSourceFileService.cs (1)

28Project sourceProject,

MetadataAsSource\MetadataAsSourceFileService.cs (2)

73Project sourceProject, 252Project? project = null;

MetadataAsSource\MetadataAsSourceGeneratedFileInfo.cs (1)

28public MetadataAsSourceGeneratedFileInfo(string rootPath, Workspace sourceWorkspace, Project sourceProject, INamedTypeSymbol topLevelNamedType, bool signaturesOnly)

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (2)

228var project = solution.GetRequiredProject(projectId); 350var project = solution.GetRequiredProject(projectId);

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

60ImmutableArray<Project> projects,

NavigateTo\AbstractNavigateToSearchService.GeneratedDocumentSearch.cs (3)

22ImmutableArray<Project> projects, 61ImmutableArray<Project> projects, 76Project project, Action<RoslynNavigateToItem> onItemFound, VoidResult _, CancellationToken cancellationToken)

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (3)

146ImmutableArray<Project> projects, 187ImmutableArray<Project> projects, 212Project project,

NavigateTo\INavigateToSearcherHost.cs (2)

21INavigateToSearchService? GetNavigateToSearchService(Project project); 52public INavigateToSearchService? GetNavigateToSearchService(Project project)

NavigateTo\INavigateToSearchService.cs (3)

37ImmutableArray<Project> projects, 64ImmutableArray<Project> projects, 83ImmutableArray<Project> projects,

NavigateTo\NavigateToSearcher.cs (21)

NavigateTo\NavigateToUtilities.cs (1)

19foreach (var project in solution.Projects)

NavigateTo\RoslynNavigateToItem.cs (2)

143var firstProject = itemDocument.Project; 158var additionalProject = solution.GetRequiredProject(additionalProjectId);

Navigation\DefaultSymbolNavigationService.cs (2)

15public Task<INavigableLocation?> GetNavigableLocationAsync(ISymbol symbol, Project project, CancellationToken cancellationToken) 18public Task<bool> TrySymbolNavigationNotifyAsync(ISymbol symbol, Project project, CancellationToken cancellationToken)

Navigation\INavigableItem.cs (1)

92public static NavigableProject FromProject(Project project)

Navigation\ISymbolNavigationService.cs (2)

22Task<INavigableLocation?> GetNavigableLocationAsync(ISymbol symbol, Project project, CancellationToken cancellationToken); 26Task<bool> TrySymbolNavigationNotifyAsync(ISymbol symbol, Project project, CancellationToken cancellationToken);

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (5)

81Project sourceProject, 282var navigateProject = pendingSolution.GetRequiredProject(projectId); 306private ProjectInfo? CreateProjectInfo(Workspace workspace, Project project, ImmutableDictionary<string, string> pdbCompilationOptions, string assemblyName, string assemblyVersion, SourceHashAlgorithm checksumAlgorithm) 338SourceFileInfo?[] sourceFileInfos, Encoding encoding, ProjectId projectId, Workspace sourceWorkspace, Project sourceProject) 430public Project? MapDocument(Document document)

ProjectManagement\IProjectManagementService.cs (1)

19string GetDefaultNamespace(Project project, Workspace workspace);

RelatedDocuments\AbstractRelatedDocumentsService.cs (1)

42var project = document.Project;

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)

161var project = document.Project;

SemanticSearch\QueryExecutionContext.cs (1)

122private async ValueTask InvokeAsync(Project project, Compilation compilation, object entity, CancellationTokenSource symbolEnumerationCancellationSource, CancellationToken cancellationToken)

SemanticSearch\SemanticSearchUtilities.cs (1)

77public static Project GetQueryProject(Solution solution)

Shared\Extensions\ProjectExtensions.cs (1)

9public static Glyph GetGlyph(this Project project)

Shared\Utilities\SupportedPlatformData.cs (1)

31foreach (var project in projects)

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\TypeParameterSubstitution.cs (4)

20Project project, 34Compilation compilation, ISet<string> availableTypeParameterNames, Project project, CancellationToken cancellationToken) : AsyncSymbolVisitor 40private readonly Project _project = project; 124INamedTypeSymbol constraintType, IImmutableSet<Project> projects)

src\Analyzers\Core\CodeFixes\MatchFolderAndNamespace\AbstractChangeNamespaceToMatchFolderCodeFixProvider.CustomFixAllProvider.cs (1)

55foreach (var project in fixAllContext.Solution.Projects)

src\Analyzers\Core\CodeFixes\UpgradeProject\AbstractUpgradeProjectCodeFixProvider.cs (5)

22public abstract Solution UpgradeProject(Project project, string version); 23public abstract bool IsUpgrade(Project project, string newVersion); 43var project = context.Document.Project; 82var currentProject = currentSolution.GetRequiredProject(projectId); 93private bool CanUpgrade(Project project, string language, string version)

StackTraceExplorer\AbstractStackTraceSymbolResolver.cs (1)

16Project project,

StackTraceExplorer\StackFrameLocalMethodResolver.cs (1)

18Project project,

StackTraceExplorer\StackFrameMethodSymbolResolver.cs (1)

15public override Task<IMethodSymbol?> TryGetBestMatchAsync(Project project,

StackTraceExplorer\StackTraceExplorerService.cs (1)

99foreach (var project in solution.Projects)

StackTraceExplorer\StackTraceExplorerUtilities.cs (4)

47using var _ = PooledObjects.ArrayBuilder<Project>.GetInstance(out var candidateProjects); 48foreach (var project in solution.Projects) 80foreach (var project in candidateProjects) 110private static async Task<IMethodSymbol?> TryGetBestMatchAsync(Project project, string fullyQualifiedTypeName, StackFrameSimpleNameNode methodNode, StackFrameParameterList methodArguments, StackFrameTypeArgumentList? methodTypeArguments, CancellationToken cancellationToken)

SymbolMapping\SymbolMappingResult.cs (2)

9public Project Project { get; } 12internal SymbolMappingResult(Project project, ISymbol symbol)

SyncNamespaces\AbstractSyncNamespacesService.cs (11)

33ImmutableArray<Project> projects, 58private static async Task<ImmutableDictionary<Project, ImmutableArray<Diagnostic>>> GetDiagnosticsByProjectAsync( 59ImmutableArray<Project> projects, 64var builder = ImmutableDictionary.CreateBuilder<Project, ImmutableArray<Diagnostic>>(); 66foreach (var project in projects) 76Project project, 98ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsByProject, 156private readonly ImmutableDictionary<Project, ImmutableArray<Diagnostic>> _diagnosticsByProject; 158internal DiagnosticProvider(ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsByProject) 163public override Task<IEnumerable<Diagnostic>> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) 176public override Task<IEnumerable<Diagnostic>> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken)

SyncNamespaces\ISyncNamespacesService.cs (1)

20ImmutableArray<Project> projects, IProgress<CodeAnalysisProgress> progressTracker, CancellationToken cancellationToken);

Tagging\CompilationAvailableHelpers.cs (1)

15public static Task ComputeCompilationInCurrentProcessAsync(Project project, CancellationToken cancellationToken)

UnusedReferences\UnusedReferencesRemover.cs (1)

37foreach (var project in projects)

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

120var project = fieldDocument.Project; 319var currentProject = currentSolution.GetRequiredProject(fieldDocument.Project.Id);

ValueTracking\ValueTrackingService.cs (1)

63var project = solution.GetRequiredProject(previousTrackedItem.DocumentId.ProjectId);

Workspace\CompileTimeSolutionProvider.cs (1)

133var existingStaleProject = staleSolution.GetProject(projectState.Id);

EditAndContinue\EditAndContinueTestVerifier.cs (5)

144CreateProjects(editScripts, workspace, targetFramework, out var oldProject, out var newProject); 463private void CreateProjects(EditScriptDescription[] editScripts, AdhocWorkspace workspace, TargetFramework targetFramework, out Project oldProject, out Project newProject) 549foreach (var project in solution.Projects)

EditAndContinue\EditAndContinueWorkspaceTestBase.cs (7)

96internal static Project AddEmptyTestProject(Solution solution) 111var project = AddEmptyTestProject(solution); 302internal Guid EmitAndLoadLibraryToDebuggee(Project project, TargetFramework targetFramework = DefaultTargetFramework) 321internal Guid EmitLibrary(Project project, TargetFramework targetFramework = DefaultTargetFramework) 336Project? generatorProject = null, 359Project? generatorProject = null, 382Project? generatorProject = null,

EditAndContinue\Extensions.cs (7)

57public static Project AddTestProject(this Solution solution, string projectName, out ProjectId id) 60public static Project AddTestProject(this Solution solution, string projectName, string language, out ProjectId id) 63public static Project AddTestProject(this Solution solution, string projectName, string language, TargetFramework targetFramework, out ProjectId id) 65var project = AddTestProject(solution, projectName, language, targetFramework, id: null); 70public static Project AddTestProject(this Solution solution, string projectName, string language = LanguageNames.CSharp, TargetFramework targetFramework = TargetFramework.NetLatest, ProjectId? id = null) 81public static Document AddTestDocument(this Project project, string source, string path) 84public static Document AddTestDocument(this Project project, string source, string path, out DocumentId id)

Snippets\AbstractSnippetProviderTests.cs (2)

37var project = workspace.CurrentSolution. 127var project = workspace.CurrentSolution.

EditAndContinue\ActiveStatementsMapTests.cs (3)

122var project = solution.Projects.Single(); 179var project = solution.Projects.Single(); 232var project = solution.Projects.Single();

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (30)

126var projectQ = solution.AddTestProject("Q", NoCompilationConstants.LanguageName); 237var project = solution.AddProject("dummy_proj", "dummy_proj", NoCompilationConstants.LanguageName); 573var project = document1.Project; 627var project = document1.Project; 686var project = documentA.Project; 834var project = solution. 1215var project = AddEmptyTestProject(solution); 1326var project = document1.Project; 1369var project = document1.Project; 1654var projectC = solution.GetProjectsByName("C").Single(); 1672var projectD = solution.AddTestProject("D"); 1683var projectE = solution.AddTestProject("E", language: NoCompilationConstants.LanguageName); 1730var project = solution 1900var project = solution 1929var oldProject = project; 2199var project = solution.Projects.Single(); 2399var project = document2.Project; 2465var project = solution. 2531var project = document1.Project; 2820var project = solution.Projects.Single(); 3450var project = solution.Projects.Single(); 3509var projectA = documentA.Project; 3511var projectB = solution.AddTestProject("B").WithAssemblyName("A"). 4008var project = solution.AddProject("dummy_proj", "dummy_proj", designTimeOnly ? LanguageNames.CSharp : NoCompilationConstants.LanguageName); 4088var p = solution.AddTestProject(projectName); 4182var project = solution.Projects.Single(); 4802var oldProject = document.Project; 4822var newProject = modifiedSolution.GetProject(oldProject.Id); 4846var projectP = solution.AddTestProject("P"); 4934var oldProject = document.Project;

EditAndContinue\EditSessionActiveStatementsTests.cs (7)

44var mockCompilationOutputsProvider = new Func<Project, CompilationOutputs>(_ => new MockCompilationOutputs(Guid.NewGuid())); 72var project = solution 182var dummyProject = solution.AddProject("dummy_proj", "dummy_proj", NoCompilationConstants.LanguageName); 184var project = solution.GetProject(projectId); 349var project = solution.Projects.Single(); 529var project = solution.Projects.Single(); 670var project = solution.Projects.Single();

EditAndContinue\RemoteEditAndContinueServiceTests.cs (3)

86var project = solution.GetRequiredProject(projectId); 87var inProcOnlyProject = solution.GetRequiredProject(inProcOnlyProjectId); 183var project = solution.GetRequiredProject(projectId);

EditAndContinue\UnitTestingHotReloadServiceTests.cs (1)

31var projectP = solution.

FindUsages\DefinitionItemFactoryTests.cs (33)

LanguageServer\Handler\DebugConfiguration\WorkspaceDebugConfigurationHandler.cs (3)

42private static bool IsProjectInWorkspace(DocumentUri workspacePath, Project project) 47private ProjectDebugConfiguration GetProjectDebugConfiguration(Project project) 54private static string GetProjectName(Project project)

LanguageServer\Handler\Restore\RestorableProjectsHandler.cs (1)

37foreach (var project in context.Solution.Projects)

Extensions\Extensions.cs (1)

178public static Project? GetProject(this Solution solution, TextDocumentIdentifier projectIdentifier)

Extensions\ProtocolConversions.cs (1)

829public static LSP.VSProjectContext ProjectToProjectContext(Project project)

Extensions\ProtocolConversions.Diagnostics.cs (2)

29public static ImmutableArray<LSP.Diagnostic> ConvertDiagnostic(DiagnosticData diagnosticData, bool supportsVisualStudioExtensions, Project project, bool isLiveSource, bool potentialDuplicate, IGlobalOptionService globalOptionService) 96Project project,

ExternalAccess\Razor\FormatNewFileHandler.cs (2)

41var project = context.Solution?.GetProject(request.Project); 69var project = document.Project;

Features\EditAndContinue\EditAndContinueDiagnosticSource_Workspace.cs (1)

20private sealed class ProjectSource(Project project, ImmutableArray<DiagnosticData> diagnostics) : AbstractProjectDiagnosticSource(project)

Features\Options\BlockStructureOptionsStorage.cs (1)

11public static BlockStructureOptions GetBlockStructureOptions(this IGlobalOptionService globalOptions, Project project)

Handler\Completion\CompletionHandler.cs (1)

87var project = document.Project;

Handler\Diagnostics\AbstractPullDiagnosticHandler.cs (2)

156var project = diagnosticSource.GetProject(); 254var project = solution.GetProject(textDocumentIdentifier);

Handler\Diagnostics\BuildOnlyDiagnosticIdsHandler.cs (1)

55foreach (var project in context.Solution.Projects)

Handler\Diagnostics\DiagnosticSourceProviders\DiagnosticSourceManager.cs (1)

145public Project GetProject() => sources[0].GetProject();

Handler\Diagnostics\DiagnosticSourceProviders\WorkspaceDiagnosticSourceHelpers.cs (3)

15public static IEnumerable<Project> GetProjectsInPriorityOrder(Solution solution, ImmutableArray<string> supportedLanguages) 22static IEnumerable<Project?> GetProjectsInPriorityOrderWorker(Solution solution) 37foreach (var project in solution.Projects)

Handler\Diagnostics\DiagnosticSourceProviders\WorkspaceDocumentsAndProjectDiagnosticSourceProvider.cs (2)

59foreach (var project in WorkspaceDiagnosticSourceHelpers.GetProjectsInPriorityOrder(solution, context.SupportedLanguages)) 64async Task AddDocumentsAndProjectAsync(Project project, CancellationToken cancellationToken)

Handler\Diagnostics\DiagnosticSources\AbstractDocumentDiagnosticSource.cs (1)

25public Project GetProject() => Document.Project;

Handler\Diagnostics\DiagnosticSources\AbstractProjectDiagnosticSource.cs (7)

14internal abstract class AbstractProjectDiagnosticSource(Project project) 17protected Project Project => project; 20public static AbstractProjectDiagnosticSource CreateForFullSolutionAnalysisDiagnostics(Project project, Func<DiagnosticAnalyzer, bool>? shouldIncludeAnalyzer) 23public static AbstractProjectDiagnosticSource CreateForCodeAnalysisDiagnostics(Project project, ICodeAnalysisDiagnosticAnalyzerService codeAnalysisService) 30public Project GetProject() => Project; 37private sealed class FullSolutionAnalysisDiagnosticSource(Project project, Func<DiagnosticAnalyzer, bool>? shouldIncludeAnalyzer) 64private sealed class CodeAnalysisDiagnosticSource(Project project, ICodeAnalysisDiagnosticAnalyzerService codeAnalysisService)

Handler\Diagnostics\DiagnosticSources\AbstractWorkspaceDocumentDiagnosticSource.cs (1)

33private static readonly ConditionalWeakTable<Project, AsyncLazy<ILookup<DocumentId, DiagnosticData>>> s_projectToDiagnostics = new();

Handler\Diagnostics\DiagnosticSources\IDiagnosticSource.cs (2)

14/// Wrapper around a source for diagnostics (e.g. a <see cref="Project"/> or <see cref="Document"/>) 19Project GetProject();

Handler\Diagnostics\DiagnosticsPullCache.cs (2)

21internal readonly record struct DiagnosticsRequestState(Project Project, int GlobalStateVersion, RequestContext Context, IDiagnosticSource DiagnosticSource); 26/// cref="Project.GetDependentVersionAsync(CancellationToken)"/> while the <see cref="Checksum"/> is produced by

Handler\Diagnostics\IDiagnosticProjectInformationService.cs (3)

21VSDiagnosticProjectInformation GetDiagnosticProjectInformation(Project project); 29public VSDiagnosticProjectInformation GetDiagnosticProjectInformation(Project project) 32public static VSDiagnosticProjectInformation GetDiagnosticProjectInformationHelper(Project project)

Handler\ProjectContext\GetTextDocumentWithContextHandler.cs (1)

47var project = context.Solution.GetRequiredProject(documentId.ProjectId);

Handler\PullHandlers\VersionedPullCache.cs (1)

74Project project,

Handler\SemanticTokens\SemanticTokensHelpers.cs (1)

41var project = contextDocument.Project;

Handler\SemanticTokens\SemanticTokensRefreshQueue.cs (1)

39public async Task TryEnqueueRefreshComputationAsync(Project project, CancellationToken cancellationToken)

Handler\SourceGenerators\SourceGeneratorRefreshQueue.cs (4)

83var oldProject = e.OldSolution.GetProject(projectId); 84var newProject = e.NewSolution.GetProject(projectId); 113async Task CheckDependentVersionsAsync(Project oldProject, Project newProject)

Handler\SpellCheck\SpellCheckPullCache.cs (1)

23var project = state.Document.Project;

Handler\SpellCheck\WorkspaceSpellCheckHandler.cs (2)

54foreach (var project in solution.Projects) 61void AddDocumentsFromProject(Project? project, ImmutableArray<string> supportedLanguages)

Handler\Tasks\WorkspaceTaskDiagnosticSourceProvider.cs (1)

36foreach (var project in WorkspaceDiagnosticSourceHelpers.GetProjectsInPriorityOrder(context.Solution, context.SupportedLanguages))

Workspaces\LspMiscellaneousFilesWorkspaceProvider.cs (1)

118var project = CurrentSolution.GetRequiredProject(matchingDocument.ProjectId);

CodeActions\CodeActionResolveTests.cs (1)

301var project = testWorkspace.CurrentSolution.Projects.Single();

Completion\CompletionFeaturesTests.cs (2)

595Project project, LanguageServices languageServices, SourceText text, int caretPosition, CompletionTrigger trigger, 896Project project, LanguageServices languageServices, SourceText text, int caretPosition, CompletionTrigger trigger,

Completion\CompletionResolveTests.cs (1)

532internal override bool ShouldTriggerCompletion(Project project, LanguageServices languageServices, SourceText text, int caretPosition, CompletionTrigger trigger, CodeAnalysis.Completion.CompletionOptions options, OptionSet passthroughOptions, ImmutableHashSet<string> roles = null)

Diagnostics\PullDiagnosticTests.cs (2)

1282var project = testLspServer.TestWorkspace.CurrentSolution.Projects.Single(); 1355static DiagnosticData CreateDiagnostic(string id, Project project, Document? document = null)

FormatNewFile\FormatNewFileTests.cs (1)

66var project = testLspServer.GetCurrentSolution().Projects.First();

Hover\HoverTests.cs (2)

186foreach (var project in testLspServer.GetCurrentSolution().Projects) 547var project = testLspServer.GetCurrentSolution().Projects.Single(p => p.AssemblyName == "Net472");

Miscellaneous\LspMiscellaneousFilesWorkspaceTests.cs (1)

167var project = testLspServer.GetCurrentSolution().Projects.Single();

Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (2)

171var projectWithConfig = workspace.CurrentSolution.GetRequiredProject(testProjectWithConfig.Id); 210var projectWithoutConfig = workspace.CurrentSolution.GetRequiredProject(testProjectWithoutConfig.Id);

ProjectContext\GetTextDocumentWithContextHandlerTests.cs (1)

96foreach (var project in testLspServer.GetCurrentSolution().Projects)

RelatedDocuments\RelatedDocumentsTests.cs (5)

64var project = testLspServer.TestWorkspace.CurrentSolution.Projects.Single(); 91var project = testLspServer.TestWorkspace.CurrentSolution.Projects.Single(); 126var project = testLspServer.TestWorkspace.CurrentSolution.Projects.Single(); 154var project = testLspServer.TestWorkspace.CurrentSolution.Projects.Single(); 202var project = testLspServer.TestWorkspace.CurrentSolution.Projects.Single();

Workspaces\LspWorkspaceManagerTests.cs (4)

159var newProject = testLspServer.TestWorkspace.CurrentSolution.Projects.First().WithAssemblyName("NewCSProj1"); 192var newProject = testLspServer.TestWorkspace.CurrentSolution.Projects.First().WithAssemblyName("NewCSProj1"); 452var newProjectWorkspaceTwo = testWorkspaceTwo.CurrentSolution.Projects.First().WithAssemblyName("NewCSProj1"); 507var newProject = testWorkspace.CurrentSolution.Projects.First().WithAssemblyName(newAssemblyName);

WorkspaceProjectFactoryServiceTests.cs (1)

50var project = workspaceFactory.HostWorkspace.CurrentSolution.Projects.Single();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixesAndRefactorings\FixAllHelper.cs (1)

15Project triggerProject)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ISolutionExtensions.cs (2)

38public static Project GetRequiredProject(this Solution solution, ProjectId projectId) 40var project = solution.GetProject(projectId);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (9)

17public static TLanguageService? GetLanguageService<TLanguageService>(this Project? project) where TLanguageService : class, ILanguageService 24public static TLanguageService GetRequiredLanguageService<TLanguageService>(this Project project) where TLanguageService : class, ILanguageService 33/// Gets extended host language services, which includes language services from <see cref="Project.LanguageServices"/>. 35public static HostLanguageServices GetExtendedLanguageServices(this Project project) 44public static string? TryGetAnalyzerConfigPathForProjectConfiguration(this Project project) 47public static string? TryGetAnalyzerConfigPathForDiagnosticConfiguration(this Project project, Diagnostic diagnostic) 53private static string? TryGetAnalyzerConfigPathForProjectOrDiagnosticConfiguration(Project project, Diagnostic? diagnostic) 101public static AnalyzerConfigDocument? TryGetExistingAnalyzerConfigDocumentAtPath(this Project project, string analyzerConfigPath) 109public static async Task<Compilation> GetRequiredCompilationAsync(this Project project, CancellationToken cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (2)

59foreach (var sourceProject in solution.Projects) 77var project = solution.GetProject(symbol.ContainingAssembly, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

25public Project Project => Document.Project;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

12public static bool CanApplyParseOptionChange(this Project project, ParseOptions oldOptions, ParseOptions newOptions)

AnnotatePublicApiFix.cs (9)

37Project project = context.Document.Project; 105private readonly List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> _diagnosticsToFix; 108public FixAllAdditionalDocumentChangeAction(string title, Solution solution, List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> diagnosticsToFix) 203var diagnosticsToFix = new List<KeyValuePair<Project, ImmutableArray<Diagnostic>>>(); 211diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics)); 218Project project = fixAllContext.Project; 220diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics)); 227foreach (Project project in fixAllContext.Solution.Projects) 230diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(project, diagnostics));

DeclarePublicApiFix.cs (17)

38var project = context.Document.Project; 70private static IEnumerable<TextDocument?> GetUnshippedPublicApiFiles(Project project, bool isPublic) 97private static async Task<Solution?> GetFixAsync(TextDocument? surfaceAreaDocument, bool isPublic, Project project, string newSymbolName, ImmutableHashSet<string> siblingSymbolNamesToRemove, CancellationToken cancellationToken) 114private static Solution AddPublicApiFiles(Project project, SourceText unshippedText, bool isPublic) 122static Project AddAdditionalDocument(Project project, string name, SourceText text) 223private readonly List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> _diagnosticsToFix; 228public FixAllAdditionalDocumentChangeAction(string title, DocumentId? apiDocId, Solution solution, List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> diagnosticsToFix, bool isPublic) 244foreach (KeyValuePair<Project, ImmutableArray<Diagnostic>> pair in _diagnosticsToFix) 246Project project = pair.Key; 334var project = newSolution.GetProject(pair.Key); 354var diagnosticsToFix = new List<KeyValuePair<Project, ImmutableArray<Diagnostic>>>(); 362diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics)); 369Project project = fixAllContext.Project; 371diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics)); 378foreach (Project project in fixAllContext.Solution.Projects) 381diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(project, diagnostics));

NullableEnablePublicApiFix.cs (6)

34Project project = context.Document.Project; 73private readonly List<Project> _projectsToFix; 76public FixAllAdditionalDocumentChangeAction(string title, Solution solution, List<Project> projectsToFix) 90foreach (var project in _projectsToFix) 123var projectsToFix = new List<Project>(); 137foreach (Project project in fixAllContext.Solution.Projects)

PublicApiFixHelpers.cs (2)

62internal static TextDocument? GetPublicApiDocument(this Project project, string name) 67internal static TextDocument? GetShippedDocument(this Project project, bool isPublic)

Host\RemoteWorkspace.SolutionCreator.cs (6)

340private async Task<Solution> UpdateProjectAsync(Project project, ProjectStateChecksums oldProjectChecksums, ProjectStateChecksums newProjectChecksums, CancellationToken cancellationToken) 425private async Task<Project> UpdateDocumentsAsync<TDocumentState>( 426Project project, 472private async Task<Project> UpdateDocumentsAsync( 473Project project, 536private async Task<Project> UpdateDocumentAsync(

Host\TestUtils.cs (4)

169public static async Task<Dictionary<Checksum, object>> GetAssetMapAsync(this Project project, CancellationToken cancellationToken) 205foreach (var project in solution.Projects) 217var project = solution.GetRequiredProject(projectId); 224private static async Task AppendAssetMapAsync(this Project project, Dictionary<Checksum, object> map, CancellationToken cancellationToken)

Services\DiagnosticAnalyzer\DiagnosticComputer.cs (6)

56private readonly Project _project; 65Project project, 84Project project, 421static bool ShouldRedirectAnalyzers(Project project, AnalyzerReference reference) 471public Project Project { get; } 475public CompilationWithAnalyzersCacheEntry(Checksum solutionChecksum, Project project, CompilationWithAnalyzersPair? compilationWithAnalyzers, BidirectionalMap<string, DiagnosticAnalyzer> analyzerToIdMap)

Services\DiagnosticAnalyzer\RemoteDiagnosticAnalyzerService.cs (2)

54var project = solution.GetRequiredProject(projectId); 88var project = solution.GetRequiredProject(projectId);

Services\ExtensionMethodImportCompletion\RemoteExtensionMethodImportCompletionService.cs (1)

65var project = solution.GetRequiredProject(projectId);

Services\FindUsages\RemoteFindUsagesService.cs (2)

36var project = solution.GetRequiredProject(symbolAndProjectId.ProjectId); 60var project = solution.GetRequiredProject(symbolAndProjectId.ProjectId);

Services\SourceGeneration\RemoteSourceGenerationService.cs (4)

37var project = solution.GetRequiredProject(projectId); 57var project = solution.GetRequiredProject(projectId); 145var project = solution.GetRequiredProject(projectId); 161var project = solution.GetRequiredProject(projectId);

Services\SymbolFinder\RemoteSymbolFinderService.cs (3)

101var project = solution.GetRequiredProject(projectId); 138var project = solution.GetRequiredProject(projectId); 164var project = solution.GetRequiredProject(projectId);

Services\UnitTesting\RemoteUnitTestingSearchService.cs (2)

35var project = solution.GetRequiredProject(projectId); 57var project = solution.GetRequiredProject(projectId);

SolutionAssetStorage.cs (1)

55public ValueTask<Scope> StoreAssetsAsync(Project project, CancellationToken cancellationToken)

Verifiers\CSharpSourceGeneratorVerifier`1+Test.cs (1)

82protected override async Task<(Compilation compilation, ImmutableArray<Diagnostic> generatorDiagnostics)> GetProjectCompilationAsync(Project project, IVerifier verifier, CancellationToken cancellationToken)

Verifiers\VisualBasicSourceGeneratorVerifier`1+Test.cs (1)

67protected override async Task<(Compilation compilation, ImmutableArray<Diagnostic> generatorDiagnostics)> GetProjectCompilationAsync(Project project, IVerifier verifier, CancellationToken cancellationToken)

GenerateType\VisualBasicGenerateTypeService.vb (1)

551Friend Overrides Function IsPublicOnlyAccessibility(expression As ExpressionSyntax, project As Project) As Boolean

GoToDefinition\VisualBasicGoToDefinitionSymbolService.vb (1)

24Protected Overrides Async Function FindRelatedExplicitlyDeclaredSymbolAsync(project As Project, symbol As ISymbol, cancellationToken As CancellationToken) As Task(Of ISymbol)

EditAndContinue\VisualBasicEditAndContinueAnalyzerTests.vb (1)

118Private Shared Async Function AnalyzeDocumentAsync(oldProject As Project, newDocument As Document, Optional activeStatementMap As ActiveStatementsMap = Nothing) As Task(Of DocumentAnalysisResults)

FindSymbols\VisualBasicReferenceFinder.vb (3)

24project As Project, 37project As Project, 50project As Project,

CodeGeneration\AddImportsTests.vb (1)

31Dim project As Project = ws.AddProject(

Classification\AbstractClassificationService.cs (1)

74var project = document.Project;

Classification\Classifier.cs (2)

59Project? project, 71Project? project,

Classification\EmbeddedLanguageClassificationServiceExtensions.cs (1)

17Project project,

Classification\IEmbeddedLanguageClassificationService.cs (1)

25Project project,

Classification\SemanticClassificationCacheUtilities.cs (1)

16var project = document.Project;

CodeFixes\CodeFix.cs (3)

21public readonly Project Project; 43public CodeFix(Project project, CodeAction action, Diagnostic diagnostic) 50public CodeFix(Project project, CodeAction action, ImmutableArray<Diagnostic> diagnostics)

CodeFixes\FixAllOccurrences\DocumentBasedFixAllProvider.cs (1)

47/// other aspects of (like it's properties), or changes to the <see cref="Project"/> or <see cref="Solution"/>

CodeFixes\FixAllOccurrences\FixAllContext.cs (10)

34public Project Project => State.Project; 53/// Note that <see cref="GetDocumentDiagnosticsAsync(Document)"/>, <see cref="GetProjectDiagnosticsAsync(Project)"/> and <see cref="GetAllDiagnosticsAsync(Project)"/> methods 82Optional<(Document? document, Project project)> documentAndProject, 183Project project, 280public Task<ImmutableArray<Diagnostic>> GetProjectDiagnosticsAsync(Project project) 294public Task<ImmutableArray<Diagnostic>> GetAllDiagnosticsAsync(Project project) 309private async Task<ImmutableArray<Diagnostic>> GetProjectDiagnosticsAsync(Project project, bool includeAllDocumentDiagnostics) 331Optional<(Document? document, Project project)> documentAndProject = default, 347internal Task<ImmutableDictionary<Project, ImmutableArray<Diagnostic>>> GetProjectDiagnosticsToFixAsync()

CodeFixes\FixAllOccurrences\FixAllContext.DiagnosticProvider.cs (7)

35public abstract Task<IEnumerable<Diagnostic>> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken); 41public abstract Task<IEnumerable<Diagnostic>> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken); 67internal static async Task<ImmutableDictionary<Project, ImmutableArray<Diagnostic>>> GetProjectDiagnosticsToFixAsync( 75var project = fixAllContext.Project; 85return await ProducerConsumer<(Project project, ImmutableArray<Diagnostic> diagnostics)>.RunParallelAsync( 94var projectsAndDiagnostics = ImmutableDictionary.CreateBuilder<Project, ImmutableArray<Diagnostic>>(); 109return ImmutableDictionary<Project, ImmutableArray<Diagnostic>>.Empty;

CodeFixes\FixAllOccurrences\FixAllContextHelper.cs (1)

29var project = fixAllContext.Project;

CodeFixes\FixAllOccurrences\FixAllProvider.cs (2)

52/// of it (like attributes), or changes to the <see cref="Project"/> or <see cref="Solution"/> it points at 66/// of it (like attributes), or changes to the <see cref="Project"/> or <see cref="Solution"/> it points at

CodeFixes\FixAllOccurrences\FixAllState.cs (4)

30Project project, 48protected override FixAllState With(Document? document, Project project, FixAllScope scope, string? codeActionEquivalenceKey) 86ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsToFix, 90var triggerProject = diagnosticsToFix.First().Key;

CodeFixes\FixAllOccurrences\FixAllState.FixMultipleDiagnosticProvider.cs (5)

22public ImmutableDictionary<Project, ImmutableArray<Diagnostic>> ProjectDiagnosticsMap { get; } 27ProjectDiagnosticsMap = ImmutableDictionary<Project, ImmutableArray<Diagnostic>>.Empty; 30public FixMultipleDiagnosticProvider(ImmutableDictionary<Project, ImmutableArray<Diagnostic>> diagnosticsMap) 36public override Task<IEnumerable<Diagnostic>> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) 69public override Task<IEnumerable<Diagnostic>> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken)

CodeFixes\Supression\IConfigurationFixProvider.cs (1)

34Task<ImmutableArray<CodeFix>> GetFixesAsync(Project project, IEnumerable<Diagnostic> diagnostics, CancellationToken cancellationToken);

CodeFixesAndRefactorings\CommonFixAllState.cs (5)

20public Project Project { get; } 28Project project, 43protected abstract TFixAllState With(Document? document, Project project, FixAllScope scope, string? codeActionEquivalenceKey); 46Optional<(Document? document, Project project)> documentAndProject = default, 71Optional<(Document? document, Project project)> documentAndProject,

CodeFixesAndRefactorings\FixAllLogger.cs (1)

165public static void LogDiagnosticsStats(int correlationId, ImmutableDictionary<Project, ImmutableArray<Diagnostic>> projectsAndDiagnosticsToFixMap)

CodeFixesAndRefactorings\IFixAllContext.cs (1)

23Optional<(Document? document, Project project)> documentAndProject = default,

CodeFixesAndRefactorings\IFixAllState.cs (2)

20Project Project { get; } 29Optional<(Document? document, Project project)> documentAndProject = default,

CodeRefactorings\FixAllOccurences\DocumentBasedFixAllProvider.cs (1)

49/// or changes to the <see cref="Project"/> or <see cref="Solution"/> it points at will be considered.

CodeRefactorings\FixAllOccurences\FixAllContext.cs (3)

61public Project Project => State.Project; 73Optional<(Document? document, Project project)> documentAndProject, 98Optional<(Document? document, Project project)> documentAndProject = default,

CodeRefactorings\FixAllOccurences\FixAllProvider.cs (2)

50/// of it (like attributes), or changes to the <see cref="Project"/> or <see cref="Solution"/> it points at 64/// of it (like attributes), or changes to the <see cref="Project"/> or <see cref="Solution"/> it points at

CodeRefactorings\FixAllOccurences\FixAllState.cs (3)

48Project project, 61Project project, 73protected override FixAllState With(Document? document, Project project, FixAllScope scope, string? codeActionEquivalenceKey)

Diagnostics\DiagnosticAnalysisResult.cs (2)

77Project project, 156private static void VerifyDocumentMap(Project project, ImmutableDictionary<DocumentId, ImmutableArray<DiagnosticData>> map)

Diagnostics\DiagnosticAnalysisResultBuilder.cs (2)

19internal struct DiagnosticAnalysisResultBuilder(Project project) 21public readonly Project Project = project;

Diagnostics\DiagnosticData.cs (4)

150public async Task<Diagnostic> ToDiagnosticAsync(Project project, CancellationToken cancellationToken) 200public static DiagnosticData Create(Diagnostic diagnostic, Project project) 207var project = document.Project; 304public static bool TryCreate(DiagnosticDescriptor descriptor, string[] messageArguments, Project project, [NotNullWhen(true)] out DiagnosticData? diagnosticData)

Diagnostics\Extensions.cs (12)

27private static readonly ConditionalWeakTable<Project, AsyncLazy<Checksum>> s_projectToDiagnosticChecksum = new(); 29public static async Task<ImmutableArray<Diagnostic>> ToDiagnosticsAsync(this IEnumerable<DiagnosticData> diagnostics, Project project, CancellationToken cancellationToken) 40public static ValueTask<ImmutableArray<Location>> ConvertLocationsAsync(this IReadOnlyCollection<DiagnosticDataLocation> locations, Project project, CancellationToken cancellationToken) 44this DiagnosticDataLocation dataLocation, Project project, CancellationToken cancellationToken) 110Project project, 323Project project, 371Project project, 457/// <see cref="Project.GetDependentSemanticVersionAsync(CancellationToken)"/> does not change as it only returns top level changes.</item> 459/// <see cref="Project.GetDependentSemanticVersionAsync(CancellationToken)"/> changes as the project is removed, then added resulting in a version change.</item> 465public static Task<Checksum> GetDiagnosticChecksumAsync(this Project? project, CancellationToken cancellationToken) 478static async Task<Checksum> ComputeDiagnosticChecksumAsync(Project project, CancellationToken cancellationToken) 510public static async Task<ImmutableArray<Diagnostic>> GetSourceGeneratorDiagnosticsAsync(Project project, CancellationToken cancellationToken)

Diagnostics\GeneratorDiagnosticsPlaceholderAnalyzer.cs (1)

30var project = textDocument.Project;

Diagnostics\HostDiagnosticAnalyzers.cs (2)

85public ImmutableDictionary<string, ImmutableArray<DiagnosticDescriptor>> GetDiagnosticDescriptorsPerReference(DiagnosticAnalyzerInfoCache infoCache, Project project) 124public ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>> CreateDiagnosticAnalyzersPerReference(Project project)

Editing\SymbolEditor.cs (3)

84foreach (var project in solutionChanges.GetAddedProjects()) 103var project = ChangedSolution.GetProject(symbol.ContainingAssembly, cancellationToken); 150var project = solution.GetProject(projectId);

Editing\SyntaxGenerator.cs (1)

77public static SyntaxGenerator GetGenerator(Project project)

ExternalAccess\UnitTesting\Api\UnitTestingProjectExtensions.cs (1)

15public static Task<bool> HasSuccessfullyLoadedAsync(this Project project, CancellationToken cancellationToken)

FindSymbols\Declarations\DeclarationFinder.cs (2)

19Project project, 68Project project,

FindSymbols\Declarations\DeclarationFinder_AllDeclarations.cs (3)

24Project project, SearchQuery query, SymbolFilter criteria, CancellationToken cancellationToken) 60Project project, SearchQuery query, SymbolFilter criteria, CancellationToken cancellationToken) 99var referencedProject = project.Solution.GetProject(projectReference.ProjectId);

FindSymbols\Declarations\DeclarationFinder_SourceDeclarations.cs (5)

64Project project, string name, bool ignoreCase, SymbolFilter criteria, CancellationToken cancellationToken) 135Project project, string pattern, SymbolFilter criteria, CancellationToken cancellationToken) 181foreach (var project in solution.Projects) 191Project project, string name, bool ignoreCase, SymbolFilter filter, CancellationToken cancellationToken) 246Project project, string pattern, SymbolFilter criteria, CancellationToken cancellationToken)

FindSymbols\FindReferences\DependentProjectsFinder.cs (27)

36(IAssemblySymbol assembly, Project? sourceProject, SymbolVisibility visibility), 37ImmutableArray<(Project project, bool hasInternalsAccess)>>> s_solutionToDependentProjectMap = new(); 40public static async Task<ImmutableArray<Project>> GetDependentProjectsAsync( 41Solution solution, ImmutableArray<ISymbol> symbols, IImmutableSet<Project> projects, CancellationToken cancellationToken) 73private static async Task<ImmutableArray<Project>> GetDependentProjectsWorkerAsync( 80using var _ = PooledHashSet<Project>.GetInstance(out var result); 101/// cref="IAssemblySymbol"/> for both source and metadata symbols, and an optional <see cref="Project"/> if this 104private static Dictionary<IAssemblySymbol, (Project? sourceProject, SymbolVisibility maxVisibility)> GetSymbolOriginations( 107var result = new Dictionary<IAssemblySymbol, (Project? sourceProject, SymbolVisibility visibility)>(); 120var project = assembly.Locations.Any(static loc => loc.IsInMetadata) 134private static async Task<ImmutableArray<(Project project, bool hasInternalsAccess)>> ComputeDependentProjectsAsync( 136(IAssemblySymbol assembly, Project? sourceProject) symbolOrigination, 143ImmutableArray<(Project project, bool hasInternalsAccess)> dependentProjects; 162static async Task<ImmutableArray<(Project project, bool hasInternalsAccess)>> ComputeDependentProjectsWorkerAsync( 164(IAssemblySymbol assembly, Project? sourceProject) symbolOrigination, 170using var _ = PooledHashSet<(Project, bool hasInternalsAccess)>.GetInstance(out var dependentProjects); 193Solution solution, Project? sourceProject, HashSet<(Project project, bool hasInternalsAccess)> dependentProjects, CancellationToken cancellationToken) 203var project = solution.GetRequiredProject(projectId); 215var referencedProject = solution.GetProject(previous.Assembly, cancellationToken); 259(IAssemblySymbol assembly, Project? sourceProject) symbolOrigination, 260HashSet<(Project project, bool hasInternalsAccess)> dependentProjects, 268foreach (var project in solution.Projects) 307(IAssemblySymbol assembly, Project? sourceProject) symbolOrigination, 308Project project, 324private static async Task<bool> HasReferenceToAssemblyAsync(Project project, string assemblyName, CancellationToken cancellationToken) 396static Compilation CreateCompilation(Project project)

FindSymbols\FindReferences\DependentTypeFinder.cs (14)

64IImmutableSet<Project>? projects, 132foreach (var project in orderedProjectsToExamine) 142async Task DescendInheritanceTreeInProjectAsync(Project project) 190async Task AddDescendantSourceTypesInProjectAsync(SymbolSet result, Project project) 292async Task AddDescendantMetadataTypesInProjectAsync(SymbolSet result, Project project) 334Project project, 426var sourceProject = 441ProjectDependencyGraph dependencyGraph, Project project) 448private static ImmutableArray<Project> GetOrderedProjectsToExamine( 450IImmutableSet<Project> projects, 462private static ImmutableArray<Project> OrderTopologically( 463Solution solution, IEnumerable<Project> projectsToExamine) 479private static ImmutableArray<Project> GetProjectsToExamineWorker( 481IImmutableSet<Project> projects,

FindSymbols\FindReferences\DependentTypeFinder_DerivedClasses.cs (1)

18IImmutableSet<Project>? projects,

FindSymbols\FindReferences\DependentTypeFinder_DerivedInterfaces.cs (1)

18IImmutableSet<Project>? projects,

FindSymbols\FindReferences\DependentTypeFinder_ImplementingTypes.cs (1)

17IImmutableSet<Project>? projects,

FindSymbols\FindReferences\DependentTypeFinder_ProjectIndex.cs (3)

29/// substantively different <see cref="Project"/>. For example, if the <see 43Project project, CancellationToken cancellationToken) 67private static async Task<ProjectIndex> CreateIndexAsync(Project project, CancellationToken cancellationToken)

FindSymbols\FindReferences\DependentTypeFinder_Remote.cs (2)

21IImmutableSet<Project>? projects, 55IImmutableSet<Project>? projects,

FindSymbols\FindReferences\Finders\AbstractMemberScopedReferenceFinder.cs (1)

30Project project,

FindSymbols\FindReferences\Finders\AbstractReferenceFinder.cs (15)

29ISymbol symbol, Project project, CancellationToken cancellationToken); 35ISymbol symbol, HashSet<string>? globalAliases, Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, FindReferencesSearchOptions options, CancellationToken cancellationToken); 85Project project, 118Project project, 141Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, CancellationToken cancellationToken) 148Project project, 330Project project, 346Project project, 362protected static Task FindDocumentsWithForEachStatementsAsync<TData>(Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, CancellationToken cancellationToken) 365protected static Task FindDocumentsWithUsingStatementsAsync<TData>(Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, CancellationToken cancellationToken) 804TSymbol symbol, HashSet<string>? globalAliases, Project project, IImmutableSet<Document>? documents, 814TSymbol symbol, Project project, CancellationToken cancellationToken) 820ISymbol symbol, Project project, CancellationToken cancellationToken) 828ISymbol symbol, HashSet<string>? globalAliases, Project project, 872Project project, string name, int arity, CancellationToken cancellationToken)

FindSymbols\FindReferences\Finders\ConstructorInitializerSymbolReferenceFinder.cs (1)

23Project project,

FindSymbols\FindReferences\Finders\ConstructorSymbolReferenceFinder.cs (4)

49protected override Task<ImmutableArray<string>> DetermineGlobalAliasesAsync(IMethodSymbol symbol, Project project, CancellationToken cancellationToken) 58Project project, 93private static Task FindDocumentsWithImplicitObjectCreationExpressionAsync<TData>(Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, CancellationToken cancellationToken) 97Project project,

FindSymbols\FindReferences\Finders\DestructorSymbolReferenceFinder.cs (1)

21Project project,

FindSymbols\FindReferences\Finders\DynamicTypeSymbolReferenceFinder.cs (1)

28Project project,

FindSymbols\FindReferences\Finders\EventSymbolReferenceFinder.cs (1)

52Project project,

FindSymbols\FindReferences\Finders\ExplicitConversionSymbolReferenceFinder.cs (1)

29Project project,

FindSymbols\FindReferences\Finders\ExplicitInterfaceMethodReferenceFinder.cs (1)

21Project project,

FindSymbols\FindReferences\Finders\FieldSymbolReferenceFinder.cs (1)

32Project project,

FindSymbols\FindReferences\Finders\ILanguageServiceReferenceFinder.cs (1)

20ISymbol symbol, Project project, CancellationToken cancellationToken);

FindSymbols\FindReferences\Finders\IReferenceFinder.cs (2)

28ISymbol symbol, Project project, CancellationToken cancellationToken); 55Project project, IImmutableSet<Document>? documents,

FindSymbols\FindReferences\Finders\MethodTypeParameterSymbolReferenceFinder.cs (1)

44Project project,

FindSymbols\FindReferences\Finders\NamedTypeSymbolReferenceFinder.cs (3)

23protected override Task<ImmutableArray<string>> DetermineGlobalAliasesAsync(INamedTypeSymbol symbol, Project project, CancellationToken cancellationToken) 56Project project, 83Project project,

FindSymbols\FindReferences\Finders\NamespaceSymbolReferenceFinder.cs (2)

21protected override Task<ImmutableArray<string>> DetermineGlobalAliasesAsync(INamespaceSymbol symbol, Project project, CancellationToken cancellationToken) 29Project project,

FindSymbols\FindReferences\Finders\OperatorSymbolReferenceFinder.cs (2)

24Project project, 37Project project,

FindSymbols\FindReferences\Finders\OrdinaryMethodReferenceFinder.cs (4)

50Project project, 93private static Task FindDocumentsWithDeconstructionAsync<TData>(Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, CancellationToken cancellationToken) 96private static Task FindDocumentsWithAwaitExpressionAsync<TData>(Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, CancellationToken cancellationToken) 99private static Task FindDocumentsWithCollectionInitializersAsync<TData>(Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, CancellationToken cancellationToken)

FindSymbols\FindReferences\Finders\ParameterSymbolReferenceFinder.cs (1)

27Project project,

FindSymbols\FindReferences\Finders\PreprocessingSymbolReferenceFinder.cs (1)

22Project project,

FindSymbols\FindReferences\Finders\PropertyAccessorSymbolReferenceFinder.cs (1)

35Project project,

FindSymbols\FindReferences\Finders\PropertySymbolReferenceFinder.cs (3)

110Project project, 175Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, CancellationToken cancellationToken) 182Project project, IImmutableSet<Document>? documents, Action<Document, TData> processResult, TData processResultData, CancellationToken cancellationToken)

FindSymbols\FindReferences\Finders\TypeParameterSymbolReferenceFinder.cs (1)

21Project project,

FindSymbols\FindReferences\FindReferencesSearchEngine.BidirectionalSymbolSet.cs (1)

45public override async Task InheritanceCascadeAsync(Project project, CancellationToken cancellationToken)

FindSymbols\FindReferences\FindReferencesSearchEngine.cs (6)

125private async IAsyncEnumerable<(Project project, ImmutableArray<(ISymbol symbol, SymbolGroup group)> allSymbols)> GetProjectsAndSymbolsToSearchSeriallyAsync( 127ImmutableArray<Project> projectsToSearch, 139var currentProject = _solution.GetRequiredProject(projectId); 205private Task<ImmutableArray<Project>> GetProjectsToSearchAsync( 216Project project, ImmutableArray<(ISymbol symbol, SymbolGroup group)> allSymbols, Action<Reference> onReferenceFound, CancellationToken cancellationToken) 342Project project,

FindSymbols\FindReferences\FindReferencesSearchEngine.NonCascadingSymbolSet.cs (1)

24public override Task InheritanceCascadeAsync(Project project, CancellationToken cancellationToken)

FindSymbols\FindReferences\FindReferencesSearchEngine.SymbolSet.cs (4)

56public abstract Task InheritanceCascadeAsync(Project project, CancellationToken cancellationToken); 239ImmutableHashSet<Project> projects, CancellationToken cancellationToken) 274ImmutableHashSet<Project> projects, 282var originatingProject = solution.GetOriginatingProject(symbol);

FindSymbols\FindReferences\FindReferencesSearchEngine.UnidirectionalSymbolSet.cs (1)

43public override async Task InheritanceCascadeAsync(Project project, CancellationToken cancellationToken)

FindSymbols\FindReferences\FindReferencesSearchEngine_FindReferencesInDocuments.cs (2)

64var currentProject = _solution.GetRequiredProject(projectId); 75async ValueTask PerformSearchInProjectSeriallyAsync(ImmutableArray<(ISymbol symbol, SymbolGroup group)> symbols, Project project)

FindSymbols\ReferenceLocationExtensions.cs (1)

28var project = projectGroup.Key;

FindSymbols\SymbolFinder_Declarations_AllDeclarations.cs (2)

17Project project, string name, bool ignoreCase, CancellationToken cancellationToken = default) 29Project project, string name, bool ignoreCase, SymbolFilter filter, CancellationToken cancellationToken = default)

FindSymbols\SymbolFinder_Declarations_CustomQueries.cs (4)

61var project = solution.GetRequiredProject(projectId); 73public static Task<IEnumerable<ISymbol>> FindSourceDeclarationsAsync(Project project, Func<string, bool> predicate, CancellationToken cancellationToken = default) 79public static async Task<IEnumerable<ISymbol>> FindSourceDeclarationsAsync(Project project, Func<string, bool> predicate, SymbolFilter filter, CancellationToken cancellationToken = default) 89Project project, SearchQuery query, SymbolFilter filter, CancellationToken cancellationToken)

FindSymbols\SymbolFinder_Declarations_SourceDeclarations.cs (4)

40public static Task<IEnumerable<ISymbol>> FindSourceDeclarationsAsync(Project project, string name, bool ignoreCase, CancellationToken cancellationToken = default) 47Project project, string name, bool ignoreCase, SymbolFilter filter, CancellationToken cancellationToken = default) 95public static Task<IEnumerable<ISymbol>> FindSourceDeclarationsWithPatternAsync(Project project, string pattern, CancellationToken cancellationToken = default) 106Project project, string pattern, SymbolFilter filter, CancellationToken cancellationToken = default)

FindSymbols\SymbolFinder_Hierarchy.cs (19)

FindSymbols\SymbolTree\ISymbolTreeInfoCacheService.cs (3)

12/// Computes and caches <see cref="SymbolTreeInfo"/> indices for the source symbols in <see cref="Project"/>s and 17ValueTask<SymbolTreeInfo?> TryGetPotentiallyStaleSourceSymbolTreeInfoAsync(Project project, CancellationToken cancellationToken); 18ValueTask<SymbolTreeInfo?> TryGetPotentiallyStaleMetadataSymbolTreeInfoAsync(Project project, PortableExecutableReference reference, CancellationToken cancellationToken);

FindSymbols\SymbolTree\SymbolTreeInfo.cs (1)

21/// cref="Project"/> or <see cref="PortableExecutableReference"/>. This tree can be used to quickly determine if

FindSymbols\SymbolTree\SymbolTreeInfo_Source.cs (5)

31private static string GetSourceKeySuffix(Project project) 35Project project, Checksum checksum, CancellationToken cancellationToken) 54Project project, CancellationToken cancellationToken) 71public static Task<Checksum> GetSourceSymbolsChecksumAsync(Project project, CancellationToken cancellationToken) 120Project project, Checksum checksum, CancellationToken cancellationToken)

FindSymbols\SymbolTree\SymbolTreeInfoCacheService.cs (6)

69Project project, 96Project project, CancellationToken cancellationToken) 128var project = solution.GetProject(projectId); 144private async Task AnalyzeProjectAsync(Project project, CancellationToken cancellationToken) 159private async Task UpdateSourceSymbolTreeInfoAsync(Project project, CancellationToken cancellationToken) 191Project project,

Packaging\IPackageInstallerService.cs (1)

29ImmutableArray<Project> GetProjectsWithInstalledPackage(Solution solution, string packageName, string version);

Recommendations\Recommender.cs (1)

58private static RecommendationServiceOptions GetOptions(OptionSet? options, Project project)

Remote\RemoteArguments.cs (5)

62var project = solution.GetOriginatingProject(symbol); 68public static SerializableSymbolAndProjectId Create(ISymbol symbol, Project project, CancellationToken cancellationToken) 75var project = solution.GetOriginatingProject(symbol); 86ISymbol symbol, Project project, CancellationToken cancellationToken, 103var project = solution.GetRequiredProject(projectId);

Remote\RemoteHostClient.cs (5)

31public static Task<RemoteHostClient?> TryGetClientAsync(Project project, CancellationToken cancellationToken) 140Project project, 167Project project, 209Project project, 226Project project,

Remote\RemoteServiceConnection.cs (4)

79Project project, 85Project project, 129Project project, 135Project project,

Rename\ConflictEngine\ConflictResolver.cs (1)

238var projectOpt = conflictResolution.CurrentSolution.GetProject(projectId);

Rename\ConflictEngine\ConflictResolver.Session.cs (2)

351var currentProject = conflictResolution.CurrentSolution.GetRequiredProject(projectId); 478private async Task<ImmutableHashSet<ISymbol>?> GetNonConflictSymbolsAsync(Project currentProject)

Rename\Renamer.RenameDocumentActionSet.cs (1)

140var project = solution.GetRequiredProject(_documentId.ProjectId);

Shared\Extensions\ISolutionExtensions.cs (1)

26var project = solution.GetProject(projectId)!;

Shared\Extensions\ProjectExtensions.cs (12)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixesAndRefactorings\FixAllHelper.cs (1)

15Project triggerProject)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ISolutionExtensions.cs (3)

38public static Project GetRequiredProject(this Solution solution, ProjectId projectId) 40var project = solution.GetProject(projectId); 81var project = solution.GetRequiredProject(documentId.ProjectId);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (9)

17public static TLanguageService? GetLanguageService<TLanguageService>(this Project? project) where TLanguageService : class, ILanguageService 24public static TLanguageService GetRequiredLanguageService<TLanguageService>(this Project project) where TLanguageService : class, ILanguageService 33/// Gets extended host language services, which includes language services from <see cref="Project.LanguageServices"/>. 35public static HostLanguageServices GetExtendedLanguageServices(this Project project) 44public static string? TryGetAnalyzerConfigPathForProjectConfiguration(this Project project) 47public static string? TryGetAnalyzerConfigPathForDiagnosticConfiguration(this Project project, Diagnostic diagnostic) 53private static string? TryGetAnalyzerConfigPathForProjectOrDiagnosticConfiguration(Project project, Diagnostic? diagnostic) 101public static AnalyzerConfigDocument? TryGetExistingAnalyzerConfigDocumentAtPath(this Project project, string analyzerConfigPath) 109public static async Task<Compilation> GetRequiredCompilationAsync(this Project project, CancellationToken cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (2)

59foreach (var sourceProject in solution.Projects) 77var project = solution.GetProject(symbol.ContainingAssembly, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

25public Project Project => Document.Project;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

12public static bool CanApplyParseOptionChange(this Project project, ParseOptions oldOptions, ParseOptions newOptions)

Storage\SQLite\v2\SQLitePersistentStorage_ProjectSerialization.cs (3)

17protected override Task<bool> ChecksumMatchesAsync(ProjectKey projectKey, Project? project, string name, Checksum checksum, CancellationToken cancellationToken) 20protected override Task<Stream?> ReadStreamAsync(ProjectKey projectKey, Project? project, string name, Checksum? checksum, CancellationToken cancellationToken) 23protected override Task<bool> WriteStreamAsync(ProjectKey projectKey, Project? project, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken)

Storage\SQLite\v2\SQLitePersistentStorageConstants.cs (1)

66/// Inside the DB we have a table for data that we want associated with a <see cref="Project"/>. The data is

Workspace\AdhocWorkspace.cs (2)

63public Project AddProject(string name, string language) 72public Project AddProject(ProjectInfo projectInfo)

Workspace\Host\ISupportedChangesService.cs (4)

21bool CanApplyCompilationOptionChange(CompilationOptions oldOptions, CompilationOptions newOptions, Project project); 24bool CanApplyParseOptionChange(ParseOptions oldOptions, ParseOptions newOptions, Project project); 44public bool CanApplyCompilationOptionChange(CompilationOptions oldOptions, CompilationOptions newOptions, Project project) 47public bool CanApplyParseOptionChange(ParseOptions oldOptions, ParseOptions newOptions, Project project)

Workspace\Host\PersistentStorage\AbstractPersistentStorage.cs (8)

Workspace\Host\PersistentStorage\IChecksummedPersistentStorage.cs (3)

29Task<bool> ChecksumMatchesAsync(Project project, string name, Checksum checksum, CancellationToken cancellationToken = default); 52Task<Stream?> ReadStreamAsync(Project project, string name, Checksum? checksum = null, CancellationToken cancellationToken = default); 84Task<bool> WriteStreamAsync(Project project, string name, Stream stream, Checksum? checksum = null, CancellationToken cancellationToken = default);

Workspace\Host\PersistentStorage\IPersistentStorage.cs (2)

19Task<Stream?> ReadStreamAsync(Project project, string name, CancellationToken cancellationToken = default); 32Task<bool> WriteStreamAsync(Project project, string name, Stream stream, CancellationToken cancellationToken = default);

Workspace\Host\PersistentStorage\NoOpPersistentStorage.cs (5)

26public Task<bool> ChecksumMatchesAsync(Project project, string name, Checksum checksum, CancellationToken cancellationToken) 41public Task<Stream?> ReadStreamAsync(Project project, string name, CancellationToken cancellationToken) 50public Task<Stream?> ReadStreamAsync(Project project, string name, Checksum? checksum, CancellationToken cancellationToken) 65public Task<bool> WriteStreamAsync(Project project, string name, Stream stream, CancellationToken cancellationToken) 74public Task<bool> WriteStreamAsync(Project project, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken)

Workspace\Host\PersistentStorage\ProjectKey.cs (3)

12/// <see cref="Project"/> without needing to have the entire <see cref="Project"/> snapshot available. 34public static ProjectKey ToProjectKey(Project project)

Workspace\IWorkspaceConfigurationService.cs (1)

26/// Options that affect behavior of workspace core APIs (<see cref="Solution"/>, <see cref="Project"/>, <see

Workspace\ProjectSystem\ProjectSystemProject.cs (4)

590var projectBeforeMutations = solutionChanges.Solution.GetRequiredProject(Id); 673Project projectBeforeMutation, 798var project = solution.GetRequiredProject(projectId); 1395var project = w.CurrentSolution.GetRequiredProject(Id);

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (5)

52private readonly Action<Project> _onProjectRemoved; 82Action<Project> onProjectRemoved, 387Project project = null!; 869Func<Project, IEnumerable<TReference>> getReferences, 880foreach (var project in initialSolution.Projects)

Workspace\Solution\AdditionalDocument.cs (1)

12internal AdditionalDocument(Project project, TextDocumentState state)

Workspace\Solution\AnalyzerConfigDocument.cs (1)

9internal AnalyzerConfigDocument(Project project, AnalyzerConfigDocumentState state)

Workspace\Solution\AssetPath.cs (1)

12/// particular, this is often used to scope to a particular <see cref="Project"/> or <see cref="Document"/> to avoid

Workspace\Solution\Document.cs (2)

45internal Document(Project project, DocumentState state) 546/// returned if the compilation for its <see cref="Project"/> was already produced. In this case, generators and

Workspace\Solution\Project.cs (33)

Workspace\Solution\ProjectChanges.cs (14)

Workspace\Solution\ProjectId.cs (1)

15/// An identifier that can be used to refer to the same <see cref="Project"/> across versions.

Workspace\Solution\Solution.cs (17)

33private readonly Dictionary<ProjectId, Project> _projectIdToProjectMap = []; 133public IEnumerable<Project> Projects => ProjectIds.Select(id => GetProject(id)!); 151public Project? GetProject(ProjectId? projectId) 164private static readonly Func<ProjectId, Solution, Project> s_createProjectFunction = CreateProject; 165private static Project CreateProject(ProjectId projectId, Solution solution) 174/// Gets the <see cref="Project"/> associated with an assembly symbol. 176public Project? GetProject(IAssemblySymbol assemblySymbol, 185/// Given a <paramref name="symbol"/> returns the <see cref="ProjectId"/> of the <see cref="Project"/> it came 208internal Project? GetOriginatingProject(ISymbol symbol) 256var project = GetProject(documentId?.ProjectId); 271var project = GetProject(documentId?.ProjectId); 309var project = GetProject(documentId.ProjectId); 358public Project AddProject(string name, string assemblyName, string language) 1040/// Create a new <see cref="Solution"/> instance with the corresponding <see cref="Project"/>s updated to include 1643var newProject = newSolution.GetRequiredProject(newDocumentState.Id.ProjectId); 1669internal Solution WithCachedSourceGeneratorState(ProjectId projectToUpdate, Project projectWithCachedGeneratorState) 1776var project = this.GetProject(documentId.ProjectId);

Workspace\Solution\SolutionChanges.cs (2)

25public IEnumerable<Project> GetAddedProjects() 52public IEnumerable<Project> GetRemovedProjects()

Workspace\Solution\SolutionCompilationState.CompilationTracker.CompilationTrackerState.cs (2)

134/// <see cref="Project.GetCompilationAsync"/> or <see cref="Project.TryGetCompilation"/> must be from a <see

Workspace\Solution\SolutionCompilationState.cs (4)

1140/// Gets the <see cref="Project"/> associated with an assembly symbol. 1850/// <inheritdoc cref="Solution.WithCachedSourceGeneratorState(ProjectId, Project)"/> 1851public SolutionCompilationState WithCachedSourceGeneratorState(ProjectId projectToUpdate, Project projectWithCachedGeneratorState) 1919public GeneratorDriver? GetGeneratorDriver(Project project)

Workspace\Solution\SolutionCompilationState.ICompilationTracker.cs (1)

20/// Returns <see langword="true"/> if this <see cref="Project"/>/<see cref="Compilation"/> could produce the

Workspace\Solution\SolutionCompilationState.RootedSymbolSet.cs (3)

41/// A helper type for mapping <see cref="ISymbol"/> back to an originating <see cref="Project"/>/<see 45/// In IDE scenarios we have the need to map from an <see cref="ISymbol"/> to the <see cref="Project"/> that 49/// cref="SymbolKey"/>) to resolve that symbol back in that that <see cref="Project"/>.

Workspace\Solution\SolutionCompilationState.SkeletonReferenceCache.cs (2)

38/// cref="VersionStamp"/> for a project. As long as the <see cref="Project.GetDependentSemanticVersionAsync"/> for 104/// The <see cref="Project.GetDependentSemanticVersionAsync"/> version of the project that the <see

Workspace\Solution\SourceGeneratedDocument.cs (1)

16internal SourceGeneratedDocument(Project project, SourceGeneratedDocumentState state)

Workspace\Solution\TextDocument.cs (2)

22public Project Project { get; } 24internal TextDocument(Project project, TextDocumentState state, TextDocumentKind kind)

Workspace\Workspace.cs (15)

300foreach (var addedProject in changes.GetAddedProjects()) 1479foreach (var p in solution.Projects) 1495var project = solution.GetProject(pid)!; 1594foreach (var proj in solutionChanges.GetAddedProjects()) 1616foreach (var proj in solutionChanges.GetRemovedProjects()) 1858/// Called during a call to <see cref="TryApplyChanges(Solution)"/> to determine if a specific change to <see cref="Project.CompilationOptions"/> is allowed. 1867public virtual bool CanApplyCompilationOptionChange(CompilationOptions oldOptions, CompilationOptions newOptions, Project project) 1871/// Called during a call to <see cref="TryApplyChanges(Solution)"/> to determine if a specific change to <see cref="Project.ParseOptions"/> is allowed. 1880public virtual bool CanApplyParseOptionChange(ParseOptions oldOptions, ParseOptions newOptions, Project project) 2056private static ProjectInfo CreateProjectInfo(Project project) 2116var oldProject = CurrentSolution.GetRequiredProject(projectId); 2117var newProjectForAssert = oldProject.WithCompilationOptions(options); 2134var oldProject = CurrentSolution.GetRequiredProject(projectId); 2135var newProjectForAssert = oldProject.WithParseOptions(options); 2594var project = this.CurrentSolution.GetProject(projectId);

Workspace\Workspace_Editor.cs (3)

880protected virtual Project AdjustReloadedProject(Project oldProject, Project reloadedProject)

Workspace\Workspace_SourceGeneration.cs (1)

122var requestedProject = solution.GetProject(projectId);

Workspace\WorkspaceChangeEventArgs.cs (1)

39/// The id of the affected <see cref="Project"/>. Can be <see langword="null"/> if this is an change unrelated

MSBuild\MSBuildWorkspace.cs (8)

224public Task<Project> OpenProjectAsync( 240public async Task<Project> OpenProjectAsync( 263var projectResult = this.CurrentSolution.GetProject(projects[0].Id); 335var project = projectChanges.OldProject ?? projectChanges.NewProject; 455var project = this.CurrentSolution.GetRequiredProject(info.Id.ProjectId); 629var project = this.CurrentSolution.GetProject(projectId); 654var project = this.CurrentSolution.GetProject(projectReference.ProjectId); 669var project = this.CurrentSolution.GetProject(projectReference.ProjectId);

MSBuild\ProjectMap.cs (4)

63foreach (var project in solution.Projects) 72/// Add a <see cref="Project"/> to this <see cref="ProjectMap"/>. 74/// <param name="project">The <see cref="Project"/> to add to this <see cref="ProjectMap"/>.</param> 75public void Add(Project project)

MSBuildWorkspaceTestBase.cs (6)

72var project = sol.Projects.First(); 81var project = sol.Projects.First(); 90var project = sol.GetProjectsByName("VisualBasicProject").FirstOrDefault(); 99var project = sol.GetProjectsByName("VisualBasicProject").FirstOrDefault(); 128var p1 = sol.Projects.First(p => p.Language == LanguageNames.CSharp); 129var p2 = sol.Projects.First(p => p.Language == LanguageNames.VisualBasic);

NetCoreTests.cs (18)

NewlyCreatedProjectsFromDotNetNew.cs (1)

216var project = await workspace.OpenProjectAsync(projectFilePath, cancellationToken: CancellationToken.None);

VisualStudioMSBuildWorkspaceTests.cs (124)

Formatting\FormattingTestBase.cs (1)

43var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", language);

SolutionUtilities.cs (4)

27var oldProject = oldSolution.GetRequiredProject(projectId); 28var newProject = newSolution.GetRequiredProject(projectId); 99public static Tuple<Project, ProjectReference> GetSingleAddedProjectReference(Solution oldSolution, Solution newSolution) 105public static Project AddEmptyProject(Solution solution, string languageName = LanguageNames.CSharp, string name = "TestProject")

WorkspaceExtensions.cs (1)

54public static IEnumerable<Project> GetProjectsByName(this Solution solution, string name)

Workspaces\TestHostDocument.cs (1)

43var project = workspace.CurrentSolution.GetRequiredProject(_project!.Id);

Workspaces\TestWorkspace`1.cs (1)

571public override bool CanApplyParseOptionChange(ParseOptions oldOptions, ParseOptions newOptions, Project project)

CodeCleanup\AddMissingTokensTests.cs (1)

2589var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);

CodeCleanup\CodeCleanupTests.cs (1)

425var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);

CodeCleanup\FixIncorrectTokenTests.cs (1)

734var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);

CodeCleanup\NormalizeModifiersOrOperatorsTests.cs (1)

935var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);

CodeCleanup\ReduceTokenTests.cs (1)

1995var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);

CodeCleanup\RemoveUnnecessaryLineContinuationTests.cs (1)

1337var project = solution

CommandLineProject\CommandLineProjectWorkspaceTests.cs (2)

30var project = ws.CurrentSolution.GetProject(info.Id); 58var project = ws.CurrentSolution.GetProject(info.Id);

FindAllDeclarationsTests.cs (20)

FindAllDeclarationsTests.TestSolutionsAndProject.cs (1)

138private Workspace CreateWorkspaceWithProject(SolutionKind solutionKind, out Project project, TestHost testHost = TestHost.OutOfProcess)

FindReferencesTests.cs (13)

Formatter\FormatterTests.cs (4)

51var project = workspace.AddProject("Dummy", NoCompilationConstants.LanguageName); 69var project = workspace.AddProject("Dummy", NoCompilationConstants.LanguageName); 113var csProject = workspace.AddProject("CS", LanguageNames.CSharp); 114var vbProject = workspace.AddProject("VB", LanguageNames.VisualBasic);

GeneratedCodeRecognitionTests.cs (5)

57var project = CreateProject(); 59var projectWithUserConfiguredGeneratedCodeTrue = project.AddAnalyzerConfigDocument(".editorconfig", 65var projectWithUserConfiguredGeneratedCodeFalse = project.AddAnalyzerConfigDocument(".editorconfig", 83static void TestCore(string fileName, Project project, bool assertGenerated) 97private static Project CreateProject()

SemanticModelReuse\SemanticModelReuseTests.cs (1)

28var project = solution.AddProject(projectId, "Project", "Project.dll", language).GetProject(projectId);

Simplifier\SimplifierTests.cs (3)

28var project = workspace.AddProject("CSharpTest", LanguageNames.CSharp); 76var csProject = workspace.AddProject("CS", LanguageNames.CSharp); 77var vbProject = workspace.AddProject("VB", LanguageNames.VisualBasic);

SolutionTests\ProjectDependencyGraphTests.cs (11)

SolutionTests\ProjectSemanticVersionTests.cs (6)

22var project = AddEmptyProject(workspace.CurrentSolution); 31var project = AddEmptyProject(workspace.CurrentSolution) 261private static async Task AssertSemanticVersionChangedAsync(Project project1, Project project2) 266private static async Task AssertSemanticVersionUnchangedAsync(Project project1, Project project2)

SolutionTests\SolutionTests.cs (81)

SolutionTests\SolutionWithSourceGeneratorTests.cs (54)

SolutionTests\SourceGeneratorTelemetryCollectorWorkspaceServiceTests.cs (1)

31var project = AddEmptyProject(workspace.CurrentSolution)

SolutionTests\TryApplyChangesTests.cs (9)

48public override bool CanApplyParseOptionChange(ParseOptions oldOptions, ParseOptions newOptions, Project project) 58public override bool CanApplyCompilationOptionChange(CompilationOptions oldOptions, CompilationOptions newOptions, Project project) 78var project = workspace.CurrentSolution.Projects.Single(); 91var project = workspace.CurrentSolution.Projects.Single(); 104var project = workspace.CurrentSolution.Projects.Single(); 121var project = workspace.CurrentSolution.Projects.Single(); 136var project = workspace.CurrentSolution.Projects.Single(); 151var project = workspace.CurrentSolution.Projects.Single(); 165var project = workspace.CurrentSolution.Projects.Single();

SymbolKeyTests.cs (2)

852var project = workspace.AddProject("Test", LanguageNames.CSharp); 899var project = workspace.AddProject("Test", LanguageNames.CSharp);

WorkspaceTests\AdhocWorkspaceTests.cs (9)

36var project = ws.AddProject(info); 48var project = ws.AddProject("TestProject", LanguageNames.CSharp); 58var project = ws.AddProject("TestProject", LanguageNames.CSharp); 70var project = ws.AddProject("TestProject", LanguageNames.CSharp); 98var project = solution.Projects.FirstOrDefault(); 131var project1 = solution.GetProject(id1); 137var project2 = solution.GetProject(id2); 173var proj = ws.CurrentSolution.Projects.First(); 382var proj = pws.CurrentSolution.GetProject(projid);

WorkspaceTests\WorkspaceReferenceTests.cs (9)

28var project = ws.AddProject(projectInfo); 57var referenceProject = ws.AddProject(referenceInfo); 68var project = ws.AddProject(projectInfo); 97var referenceProject = ws.AddProject(referenceInfo); 108var project = ws.AddProject(projectInfo); 137var referenceProject = ws.AddProject(referenceInfo); 148var project = ws.AddProject(projectInfo); 181var project = ws.AddProject(projectInfo); 188var forkedProject = project.WithMetadataReferences(

WorkspaceTests\WorkspaceTests.cs (2)

127public Project AddProject(string name, string language) 133public Project AddProject(ProjectInfo projectInfo)

test\Generators\Shared\RoslynTestUtils.cs (14)

41public static Project CreateTestProject(IEnumerable<Assembly>? references, bool includeBaseReferences = true) 52public static Project CreateTestProject( 88public static void CommitChanges(this Project proj) 93public static Project WithDocument(this Project proj, string name, string text) 98public static Document FindDocument(this Project proj, string name) 267var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences); 310var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences, langVersion); 361var proj = CreateTestProject(references, includeBaseReferences); 397var proj = CreateTestProject(references); 443var proj = CreateTestProject(references); 498var changedProj = solution.GetProject(proj.Id); 534private static async Task<Project> RecreateProjectDocumentsAsync(Project project)

test\Generators\Shared\RoslynTestUtils.cs (14)

41public static Project CreateTestProject(IEnumerable<Assembly>? references, bool includeBaseReferences = true) 52public static Project CreateTestProject( 88public static void CommitChanges(this Project proj) 93public static Project WithDocument(this Project proj, string name, string text) 98public static Document FindDocument(this Project proj, string name) 267var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences); 310var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences, langVersion); 361var proj = CreateTestProject(references, includeBaseReferences); 397var proj = CreateTestProject(references); 443var proj = CreateTestProject(references); 498var changedProj = solution.GetProject(proj.Id); 534private static async Task<Project> RecreateProjectDocumentsAsync(Project project)

test\Generators\Shared\RoslynTestUtils.cs (14)

41public static Project CreateTestProject(IEnumerable<Assembly>? references, bool includeBaseReferences = true) 52public static Project CreateTestProject( 88public static void CommitChanges(this Project proj) 93public static Project WithDocument(this Project proj, string name, string text) 98public static Document FindDocument(this Project proj, string name) 267var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences); 310var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences, langVersion); 361var proj = CreateTestProject(references, includeBaseReferences); 397var proj = CreateTestProject(references); 443var proj = CreateTestProject(references); 498var changedProj = solution.GetProject(proj.Id); 534private static async Task<Project> RecreateProjectDocumentsAsync(Project project)

test\Generators\Shared\RoslynTestUtils.cs (14)

41public static Project CreateTestProject(IEnumerable<Assembly>? references, bool includeBaseReferences = true) 52public static Project CreateTestProject( 88public static void CommitChanges(this Project proj) 93public static Project WithDocument(this Project proj, string name, string text) 98public static Document FindDocument(this Project proj, string name) 267var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences); 310var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences, langVersion); 361var proj = CreateTestProject(references, includeBaseReferences); 397var proj = CreateTestProject(references); 443var proj = CreateTestProject(references); 498var changedProj = solution.GetProject(proj.Id); 534private static async Task<Project> RecreateProjectDocumentsAsync(Project project)

test\Generators\Shared\RoslynTestUtils.cs (14)

41public static Project CreateTestProject(IEnumerable<Assembly>? references, bool includeBaseReferences = true) 52public static Project CreateTestProject( 88public static void CommitChanges(this Project proj) 93public static Project WithDocument(this Project proj, string name, string text) 98public static Document FindDocument(this Project proj, string name) 267var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences); 310var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences, langVersion); 361var proj = CreateTestProject(references, includeBaseReferences); 397var proj = CreateTestProject(references); 443var proj = CreateTestProject(references); 498var changedProj = solution.GetProject(proj.Id); 534private static async Task<Project> RecreateProjectDocumentsAsync(Project project)

test\Generators\Shared\RoslynTestUtils.cs (14)

41public static Project CreateTestProject(IEnumerable<Assembly>? references, bool includeBaseReferences = true) 52public static Project CreateTestProject( 88public static void CommitChanges(this Project proj) 93public static Project WithDocument(this Project proj, string name, string text) 98public static Document FindDocument(this Project proj, string name) 267var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences); 310var proj = CreateTestProject(references, preprocessorSymbols, includeBaseReferences, langVersion); 361var proj = CreateTestProject(references, includeBaseReferences); 397var proj = CreateTestProject(references); 443var proj = CreateTestProject(references); 498var changedProj = solution.GetProject(proj.Id); 534private static async Task<Project> RecreateProjectDocumentsAsync(Project project)

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (3)

183HashSet<Project> projectsToAddUnsafe = new(); 216foreach (var project in projectsToAddUnsafe) 227private static Solution AddUnsafe(Solution solution, Project project)

src\libraries\System.Runtime.InteropServices\gen\Common\FixAllContextExtensions.cs (6)

39IEnumerable<Project?> sortedProjects = dependencyGraph.GetTopologicallySortedProjects(context.CancellationToken) 48public static async Task<ImmutableArray<Project>> GetProjectsWithDiagnosticsAsync(this FixAllContext context) 58ImmutableArray<Project>.Builder projectsWithDiagnostics = ImmutableArray.CreateBuilder<Project>(); 59foreach (var project in context.Solution.Projects) 69return ImmutableArray<Project>.Empty;

Analyzers\AddDisableRuntimeMarshallingAttributeFixer.cs (1)

52private static async Task<Solution> AddDisableRuntimeMarshallingAttributeApplicationToProject(Project project, CancellationToken cancellationToken)

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (3)

183HashSet<Project> projectsToAddUnsafe = new(); 216foreach (var project in projectsToAddUnsafe) 227private static Solution AddUnsafe(Solution solution, Project project)

src\libraries\System.Runtime.InteropServices\gen\Common\FixAllContextExtensions.cs (6)

39IEnumerable<Project?> sortedProjects = dependencyGraph.GetTopologicallySortedProjects(context.CancellationToken) 48public static async Task<ImmutableArray<Project>> GetProjectsWithDiagnosticsAsync(this FixAllContext context) 58ImmutableArray<Project>.Builder projectsWithDiagnostics = ImmutableArray.CreateBuilder<Project>(); 59foreach (var project in context.Solution.Projects) 69return ImmutableArray<Project>.Empty;

Code\BestFriendTest.cs (1)

66var projectA = solution.AddProject("ProjectA", "ProjectA", LanguageNames.CSharp);

CallHierarchy\CallHierarchyItem.cs (1)

39Project project)

CallHierarchy\CallHierarchyProvider.cs (2)

55ISymbol symbol, Project project, ImmutableArray<Location> callsites, CancellationToken cancellationToken) 100public async Task<ImmutableArray<AbstractCallFinder>> CreateFindersAsync(ISymbol symbol, Project project, CancellationToken cancellationToken)

CallHierarchy\Finders\AbstractCallFinder.cs (6)

94var project = workspace.CurrentSolution.GetProject(_projectId); 116private static IImmutableSet<Document> IncludeDocuments(CallHierarchySearchScope scope, Project project) 126var currentProject = project.Solution.GetProject(activeDocument.ProjectId); 148protected virtual async Task SearchWorkerAsync(ISymbol symbol, Project project, ICallHierarchySearchCallback callback, IImmutableSet<Document> documents, CancellationToken cancellationToken) 165var callingProject = project.Solution.GetProject(caller.CallingSymbol.ContainingAssembly, cancellationToken); 180protected abstract Task<IEnumerable<SymbolCallerInfo>> GetCallersAsync(ISymbol symbol, Project project, IImmutableSet<Document> documents, CancellationToken cancellationToken);

CallHierarchy\Finders\BaseMemberFinder.cs (1)

27protected override async Task<IEnumerable<SymbolCallerInfo>> GetCallersAsync(ISymbol symbol, Project project, IImmutableSet<Document> documents, CancellationToken cancellationToken)

CallHierarchy\Finders\CallToOverrideFinder.cs (1)

23protected override async Task<IEnumerable<SymbolCallerInfo>> GetCallersAsync(ISymbol symbol, Project project, IImmutableSet<Document> documents, CancellationToken cancellationToken)

CallHierarchy\Finders\FieldReferenceFinder.cs (1)

30protected override async Task<IEnumerable<SymbolCallerInfo>> GetCallersAsync(ISymbol symbol, Project project, IImmutableSet<Document> documents, CancellationToken cancellationToken)

CallHierarchy\Finders\ImplementerFinder.cs (2)

33protected override Task<IEnumerable<SymbolCallerInfo>> GetCallersAsync(ISymbol symbol, Project project, IImmutableSet<Document> documents, CancellationToken cancellationToken) 36protected override async Task SearchWorkerAsync(ISymbol symbol, Project project, ICallHierarchySearchCallback callback, IImmutableSet<Document> documents, CancellationToken cancellationToken)

CallHierarchy\Finders\InterfaceImplementationCallFinder.cs (1)

30protected override async Task<IEnumerable<SymbolCallerInfo>> GetCallersAsync(ISymbol symbol, Project project, IImmutableSet<Document> documents, CancellationToken cancellationToken)

CallHierarchy\Finders\MethodCallFinder.cs (1)

33protected override async Task<IEnumerable<SymbolCallerInfo>> GetCallersAsync(ISymbol symbol, Project project, IImmutableSet<Document> documents, CancellationToken cancellationToken)

CallHierarchy\Finders\OverridingMemberFinder.cs (2)

29protected override Task<IEnumerable<SymbolCallerInfo>> GetCallersAsync(ISymbol symbol, Project project, IImmutableSet<Document> documents, CancellationToken cancellationToken) 32protected override async Task SearchWorkerAsync(ISymbol symbol, Project project, ICallHierarchySearchCallback callback, IImmutableSet<Document> documents, CancellationToken cancellationToken)

CodeCleanup\AbstractCodeCleanUpFixer.cs (2)

92var project = _workspace.CurrentSolution.GetProject(projectId); 195ImmutableArray<Project> projects,

CodeLens\CodeLensCallbackListener.cs (1)

69foreach (var project in solution.Projects)

Diagnostics\VisualStudioDiagnosticAnalyzerService.cs (4)

89var project = projectsWithHierarchy.FirstOrDefault(); 99foreach (var project in projectsWithHierarchy) 172var project = GetProject(solution, hierarchy); 218private Project? GetProject(Solution solution, IVsHierarchy? hierarchy)

EditorConfigSettings\DataProvider\CodeStyle\CommonCodeStyleSettingsProvider.cs (1)

24protected override void UpdateOptions(TieredAnalyzerConfigOptions options, ImmutableArray<Project> projectsInScope)

EditorConfigSettings\DataProvider\Whitespace\CommonWhitespaceSettingsProvider.cs (1)

24protected override void UpdateOptions(TieredAnalyzerConfigOptions options, ImmutableArray<Project> projectsInScope)

GenerateType\GenerateTypeDialogViewModel.cs (5)

387public Project SelectedProject 393var previousProject = field; 468private Project _previouslyPopulatedProject = null; 753public Project Project { get; } 755public ProjectSelectItem(Project project)

Implementation\AbstractEditorFactory.cs (7)

49protected abstract Project GetProjectWithCorrectParseOptionsForProject(Project project, IVsHierarchy hierarchy); 293Project? projectToAddTo = null; 376private static Project AddEditorConfigFiles(Project projectToAddTo, string projectFolder) 391static Project AddEditorConfigFile(Project project, string folder, out bool foundRoot)

Implementation\HierarchyItemToProjectIdMap.cs (4)

25public bool TryGetProject(IVsHierarchyItem? hierarchyItem, string? targetFrameworkMoniker, [NotNullWhen(true)] out Project? project) 29Solution solution, IVsHierarchyItem? hierarchyItem, string? targetFrameworkMoniker, [NotNullWhen(true)] out Project? project) 43using var candidateProjects = TemporaryArray<Project>.Empty; 52var currentProject = solution.GetProject(currentId);

Implementation\IHierarchyItemToProjectIdMap.cs (4)

19/// returns the <see cref="ProjectId"/> of the equivalent Roslyn <see cref="Project"/>. 25/// <param name="project">The <see cref="Project"/> of the found project, if any.</param> 30bool TryGetProject(IVsHierarchyItem hierarchyItem, string? targetFrameworkMoniker, [NotNullWhen(true)] out Project? project); 39if (!idMap.TryGetProject(hierarchyItem, targetFrameworkMoniker, out var project))

Interactive\VsResetInteractive.cs (2)

111var projectOpt = GetProjectFromHierarchy(hierarchy); 163internal Project GetProjectFromHierarchy(IVsHierarchy hierarchy)

LanguageServer\Handler\Diagnostics\VisualStudioDiagnosticProjectInformationService.cs (1)

19public VSDiagnosticProjectInformation GetDiagnosticProjectInformation(Project project)

LanguageService\AbstractCreateServicesOnTextViewConnection.cs (2)

39protected virtual Task InitializeServiceForProjectWithOpenedDocumentAsync(Project project) 90else if (Workspace.CurrentSolution.GetProject(projectId) is Project project)

Library\ObjectBrowser\AbstractDescriptionBuilder.cs (2)

24private readonly Project _project; 33Project project)

Library\ObjectBrowser\AbstractListItemFactory.cs (3)

474var project = solution.GetProject(projectId); 507public async Task<ImmutableHashSet<(ProjectId, IAssemblySymbol)>> GetAssemblySetAsync(Project project, bool lookInReferences, CancellationToken cancellationToken) 599var project = solution.GetProject(projectId);

Library\ObjectBrowser\AbstractObjectBrowserLibraryManager.cs (8)

65Project project); 188internal Project GetProject(ProjectId projectId) 191internal Project GetProject(ObjectListItem listItem) 205var project = GetProject(projectId); 417var project = GetProject(symbolListItem); 485var project = this.Workspace.CurrentSolution.GetProject(symbolListItem.ProjectId); 511IStreamingFindUsagesPresenter presenter, SymbolListItem symbolListItem, Project project, OptionsProvider<ClassificationOptions> classificationOptions) 541Project project,

Library\ObjectBrowser\AbstractObjectBrowserLibraryManager_Description.cs (1)

19var project = GetProject(listItem);

Library\ObjectBrowser\AbstractObjectBrowserLibraryManager_ListItems.cs (1)

26internal Task<ImmutableHashSet<(ProjectId, IAssemblySymbol)>> GetAssemblySetAsync(Project project, bool lookInReferences, CancellationToken cancellationToken)

Library\ObjectBrowser\Extensions.cs (5)

55public static string GetProjectDisplayName(this Project project) 81static bool IsUnambiguousProjectNameInSolution(Project project) 83foreach (var other in project.Solution.Projects) 100public static bool IsVenus(this Project project) 122public static string GetProjectNavInfoName(this Project project)

Library\ObjectBrowser\Lists\ProjectListItem.cs (2)

15public ProjectListItem(Project project) 21private static StandardGlyphGroup GetProjectGlyph(Project project)

Library\ObjectBrowser\ObjectList.cs (5)

494var project = this.LibraryManager.GetProject(listItem.ProjectId); 558var project = this.LibraryManager.GetProject(projectListItem.ProjectId); 681var project = this.LibraryManager.Workspace.CurrentSolution.GetProject(symbolListItem.ProjectId); 751var project = this.LibraryManager.Workspace.CurrentSolution.GetProject(symbolItem.ProjectId); 909var project = this.LibraryManager.Workspace.CurrentSolution.GetProject(projectListItem.ProjectId);

Library\ObjectBrowser\ObjectListItem.cs (1)

75var project = workspace.CurrentSolution.GetProject(ProjectId);

Library\VsNavInfo\NavInfoFactory.cs (7)

21public IVsNavInfo CreateForProject(Project project) 34public IVsNavInfo CreateForSymbol(ISymbol symbol, Project project, Compilation compilation, bool useExpandedHierarchy = false) 63public IVsNavInfo CreateForNamespace(INamespaceSymbol namespaceSymbol, Project project, Compilation compilation, bool useExpandedHierarchy = false) 73public IVsNavInfo CreateForType(ITypeSymbol typeSymbol, Project project, Compilation compilation, bool useExpandedHierarchy = false) 114public IVsNavInfo CreateForMember(ISymbol memberSymbol, Project project, Compilation compilation, bool useExpandedHierarchy = false) 128private IVsNavInfo Create(IAssemblySymbol containingAssembly, Project project, Compilation compilation, bool useExpandedHierarchy = false, 174private static string GetLibraryName(Project project)

NavigateTo\RoslynNavigateToSearchCallback.cs (1)

73var project = _solution.GetRequiredProject(result.NavigableItem.Document.Project.Id);

Packaging\PackageInstallerServiceFactory.cs (4)

547var project = solution.GetProject(projectId); 657public ImmutableArray<Project> GetProjectsWithInstalledPackage(Solution solution, string packageName, string version) 661using var _ = ArrayBuilder<Project>.GetInstance(out var result); 668var project = solution.GetProject(projectId);

ProjectSystem\VisualStudioProjectManagementService.cs (1)

29public string GetDefaultNamespace(Microsoft.CodeAnalysis.Project project, Workspace workspace)

ProjectSystem\VisualStudioWorkspace.cs (3)

64public abstract bool TryGoToDefinition(ISymbol symbol, Project project, CancellationToken cancellationToken); 65public abstract Task<bool> TryGoToDefinitionAsync(ISymbol symbol, Project project, CancellationToken cancellationToken); 67public abstract bool TryFindAllReferences(ISymbol symbol, Project project, CancellationToken cancellationToken);

ProjectSystem\VisualStudioWorkspaceImpl.AbstractAddDocumentUndoUnit.cs (4)

31var fromProject = currentSolution.GetProject(FromProjectId); 35var updatedProject = AddDocument(fromProject); 40protected abstract Project AddDocument(Project fromProject);

ProjectSystem\VisualStudioWorkspaceImpl.AbstractRemoveDocumentUndoUnit.cs (3)

26protected abstract IReadOnlyList<DocumentId> GetDocumentIds(Project fromProject); 33var fromProject = currentSolution.GetProject(FromProjectId); 38var updatedProject = fromProject.RemoveDocument(DocumentId);

ProjectSystem\VisualStudioWorkspaceImpl.AddAdditionalDocumentUndoUnit.cs (2)

23protected override Project AddDocument(Project fromProject)

ProjectSystem\VisualStudioWorkspaceImpl.AddAnalyzerConfigDocumentUndoUnit.cs (2)

22protected override Project AddDocument(Project fromProject)

ProjectSystem\VisualStudioWorkspaceImpl.AddDocumentUndoUnit.cs (2)

22protected override Project AddDocument(Project fromProject)

ProjectSystem\VisualStudioWorkspaceImpl.AddMetadataReferenceUndoUnit.cs (2)

32var fromProject = currentSolution.GetProject(FromProjectId); 50var updatedProject = fromProject.AddMetadataReference(reference);

ProjectSystem\VisualStudioWorkspaceImpl.AddProjectReferenceUndoUnit.cs (4)

29var fromProject = currentSolution.GetProject(FromProjectId); 30var toProject = currentSolution.GetProject(_toProjectId); 36var updatedProject = fromProject.AddProjectReference(new ProjectReference(_toProjectId)); 44var toProject = currentSolution.GetProject(_toProjectId);

ProjectSystem\VisualStudioWorkspaceImpl.cs (5)

352internal bool IsCPSProject(CodeAnalysis.Project project) 384public override bool CanApplyCompilationOptionChange(CompilationOptions oldOptions, CompilationOptions newOptions, CodeAnalysis.Project project) 387public override bool CanApplyParseOptionChange(ParseOptions oldOptions, ParseOptions newOptions, CodeAnalysis.Project project) 483var originalProject = CurrentSolution.GetRequiredProject(projectId); 1580internal void RemoveProjectFromMaps(CodeAnalysis.Project project)

ProjectSystem\VisualStudioWorkspaceImpl.RemoveAdditionalDocumentUndoUnit.cs (1)

21protected override IReadOnlyList<DocumentId> GetDocumentIds(Project fromProject)

ProjectSystem\VisualStudioWorkspaceImpl.RemoveAnalyzerConfigDocumentUndoUnit.cs (1)

21protected override IReadOnlyList<DocumentId> GetDocumentIds(Project fromProject)

ProjectSystem\VisualStudioWorkspaceImpl.RemoveDocumentUndoUnit.cs (1)

21protected override IReadOnlyList<DocumentId> GetDocumentIds(Project fromProject)

ProjectSystem\VisualStudioWorkspaceImpl.RemoveMetadataReferenceUndoUnit.cs (2)

31var fromProject = currentSolution.GetProject(FromProjectId); 39var updatedProject = fromProject.RemoveMetadataReference(reference);

ProjectSystem\VisualStudioWorkspaceImpl.RemoveProjectReferenceUndoUnit.cs (4)

29var fromProject = currentSolution.GetProject(FromProjectId); 30var toProject = currentSolution.GetProject(_toProjectId); 36var updatedProject = fromProject.RemoveProjectReference(new ProjectReference(_toProjectId)); 44var toProject = currentSolution.GetProject(_toProjectId);

PullMemberUp\SymbolDependentsBuilder.cs (3)

22Project project, 37private readonly Project _project; 45Project project,

Snippets\SnippetExpansionClient.cs (1)

1076private static void AddReferences(Project originalProject, XElement snippetNode)

SyncNamespaces\SyncNamespacesCommandHandler.cs (2)

114private ImmutableArray<Project> GetProjectsForHierarchy(Shell.Interop.IVsHierarchy projectHierarchy) 124private void SyncNamespaces(ImmutableArray<Project> projects)

TableDataSource\Suppression\VisualStudioDiagnosticListSuppressionStateService.cs (5)

195Dictionary<string, Project>? projectNameToProjectMap = null; 196Dictionary<Project, ImmutableDictionary<string, Document>>? filePathToDocumentMap = null; 224foreach (var p in _workspace.CurrentSolution.Projects) 231if (!projectNameToProjectMap.TryGetValue(projectName, out var project)) 300private static async Task<ImmutableDictionary<string, Document>> GetFilePathToDocumentMapAsync(Project project, CancellationToken cancellationToken)

TableDataSource\Suppression\VisualStudioSuppressionFixService.cs (18)

TaskList\ExternalErrorDiagnosticUpdateSource.cs (2)

219private static RpcContracts.Utilities.ProjectIdentifier? GetProjectIdentifier(Project? project, Guid projectHierarchyGuid) 359var project = Solution.GetProject(projectId);

TaskList\ProjectExternalErrorReporter.cs (1)

86var project = _workspace.CurrentSolution.GetProject(_projectId);

UnusedReferences\Dialog\UnusedReferencesTableProvider.DataSource.cs (1)

36var project = solution.Projects.First(project => projectFilePath.Equals(project.FilePath, StringComparison.OrdinalIgnoreCase));

Workspace\SourceGeneratedFileManager.cs (3)

335var project = this.Workspace.CurrentSolution.GetProject(_documentIdentity.DocumentId.ProjectId); 438var oldProject = e.OldSolution.GetProject(projectId); 439var newProject = e.NewSolution.GetProject(projectId);

Workspace\VisualStudioSymbolNavigationService.cs (3)

48ISymbol symbol, Project project, CancellationToken cancellationToken) 125Project project, ISymbol symbol, CancellationToken cancellationToken) 181public async Task<bool> TrySymbolNavigationNotifyAsync(ISymbol symbol, Project project, CancellationToken cancellationToken)

CodeModel\CSharpCodeModelService.cs (1)

645var project = state.Workspace.CurrentSolution.GetProject(projectId);

EditorConfigSettings\DataProvider\CodeStyle\CSharpCodeStyleSettingsProvider.cs (1)

28protected override void UpdateOptions(TieredAnalyzerConfigOptions options, ImmutableArray<Project> projectsInScope)

EditorConfigSettings\DataProvider\Whitespace\CSharpWhitespaceSettingsProvider.cs (1)

28protected override void UpdateOptions(TieredAnalyzerConfigOptions options, ImmutableArray<Project> projectsInScope)

LanguageService\CSharpCreateServicesOnTextViewConnection.cs (1)

40protected override async Task InitializeServiceForProjectWithOpenedDocumentAsync(Project project)

LanguageService\CSharpEditorFactory.cs (2)

24protected override Project GetProjectWithCorrectParseOptionsForProject(Project project, IVsHierarchy hierarchy)

ObjectBrowser\DescriptionBuilder.cs (1)

22Project project) : AbstractDescriptionBuilder(description, libraryManager, listItem, project)

ObjectBrowser\ObjectBrowserLibraryManager.cs (1)

24Project project)

ProjectSystemShim\CSharpProjectShim.ICSharpProjectSite.cs (1)

132var project = Workspace.CurrentSolution.GetRequiredProject(ProjectSystemProject.Id);

CodeModel\AbstractFileCodeElementTests.cs (1)

53protected Microsoft.CodeAnalysis.Project GetCurrentProject()

CodeModel\FileCodeModelTestHelpers.cs (1)

36var project = workspace.CurrentSolution.Projects.Single();

Interactive\Commands\ResetInteractiveTests.cs (3)

51var project = workspace.CurrentSolution.Projects.FirstOrDefault(p => p.AssemblyName == "ResetInteractiveTestsAssembly"); 72Project project, 144private static IEnumerable<string> GetProjectReferences(TestWorkspace workspace, Project project)

PersistentStorage\AbstractPersistentStorageTests.cs (3)

119var project = solution.Projects.First(); 221var project = solution.Projects.Single(); 988var project = solution.Projects.Single();

ProjectSystemShim\CPS\AdditionalPropertiesTests.cs (2)

57var project = environment.Workspace.CurrentSolution.Projects.Single(); 84var project = environment.Workspace.CurrentSolution.Projects.Single();

ProjectSystemShim\CPS\AnalyzersTests.cs (1)

34var workspaceProject = environment.Workspace.CurrentSolution.Projects.Single();

ProjectSystemShim\LegacyProject\AnalyzersTests.cs (2)

81var workspaceProject = environment.Workspace.CurrentSolution.Projects.Single(); 219var workspaceProject = environment.Workspace.CurrentSolution.Projects.Single();

ProjectSystemShim\LegacyProject\CSharpCompilerOptionsTests.cs (5)

35var workspaceProject = environment.Workspace.CurrentSolution.Projects.Single(); 49var workspaceProject = environment.Workspace.CurrentSolution.Projects.Single(); 63var workspaceProject = environment.Workspace.CurrentSolution.Projects.Single(); 189var project = environment.Workspace.CurrentSolution.Projects.Single(); 220var project = environment.Workspace.CurrentSolution.Projects.Single();

ProjectSystemShim\LegacyProject\OutputPathTests.cs (1)

34var workspaceProject = environment.Workspace.CurrentSolution.Projects.Single();

Client\RemoteLanguageServiceWorkspace.cs (1)

317var project = CurrentSolution.Projects.FirstOrDefault(p => p.Name == projectName && p.Language == language);

ProjectsHandler.cs (1)

27foreach (var project in solution.Projects)

CodeModel\Mocks\MockVisualStudioWorkspace.vb (3)

64Public Overrides Function TryGoToDefinition(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Boolean 68Public Overrides Function TryGoToDefinitionAsync(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Task(Of Boolean) 72Public Overrides Function TryFindAllReferences(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Boolean

ProjectSystemShim\Framework\ExtensionMethods.vb (1)

11Public Function HasMetadataReference(project As Project, path As String) As Boolean

ProjectSystemShim\Framework\TestEnvironment.vb (3)

113Public Overrides Function TryGoToDefinition(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Boolean 117Public Overrides Function TryGoToDefinitionAsync(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Task(Of Boolean) 121Public Overrides Function TryFindAllReferences(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Boolean

Diagnostics\ExternalDiagnosticUpdateSourceTests.vb (3)

319Public Function GetDiagnosticsForIdsAsync(project As Project, documentId As DocumentId, diagnosticIds As ImmutableHashSet(Of String), shouldIncludeAnalyzer As Func(Of DiagnosticAnalyzer, Boolean), includeLocalDocumentDiagnostics As Boolean, includeNonLocalDocumentDiagnostics As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetDiagnosticsForIdsAsync 323Public Function GetProjectDiagnosticsForIdsAsync(project As Project, diagnosticIds As ImmutableHashSet(Of String), shouldIncludeAnalyzer As Func(Of DiagnosticAnalyzer, Boolean), includeNonLocalDocumentDiagnostics As Boolean, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.GetProjectDiagnosticsForIdsAsync 327Public Function ForceAnalyzeProjectAsync(project As Project, cancellationToken As CancellationToken) As Task(Of ImmutableArray(Of DiagnosticData)) Implements IDiagnosticAnalyzerService.ForceAnalyzeProjectAsync

GenerateType\GenerateTypeViewModelTests.vb (1)

878Public Function GetDefaultNamespace(project As Project, workspace As Microsoft.CodeAnalysis.Workspace) As String Implements IProjectManagementService.GetDefaultNamespace

ProjectSystemShim\VisualStudioProjectTests\ProjectSystemProjectFactoryTests.vb (1)

31Dim newProjectInSolution As Project = environment.Workspace.CurrentSolution.GetProject(project1.Id)

LanguageService\VisualBasicEditorFactory.vb (2)

26Protected Overrides Function GetProjectWithCorrectParseOptionsForProject(project As Project, hierarchy As IVsHierarchy) As Project

ObjectBrowser\DescriptionBuilder.vb (1)

19project As Project)

ObjectBrowser\ObjectBrowserLibraryManager.vb (1)

21project As Project

Extensions.cs (1)

26public static Project GetCodeProject(this TextDocument document)

Features\Peek\IXamlPeekableItemFactory.cs (1)

24Task<IEnumerable<IPeekableItem>> GetPeekableItemsAsync(ISymbol symbol, Project project, IPeekResultFactory peekResultFactory, CancellationToken cancellationToken);

Implementation\LanguageServer\Extensions\SolutionExtensions.cs (1)

14public static IEnumerable<Project> GetXamlProjects(this Solution solution)

Implementation\LanguageServer\Extensions\SymbolExtensions.cs (1)

28var codeProject = document.GetCodeProject();

Implementation\LanguageServer\Handler\Definitions\GoToDefinitionHandler.cs (1)

177var project = document.GetCodeProject();

Implementation\LanguageServer\Handler\Diagnostics\AbstractPullDiagnosticHandler.cs (1)

127var project = document.Project;

Implementation\LanguageServer\Handler\Diagnostics\WorkspacePullDiagnosticHandler.cs (1)

45foreach (var project in projects)

ActualApiResponseMetadataFactoryTest.cs (4)

69var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { source }); 365var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { testSource.Source }); 405var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { source }); 425var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { testSource.Source });

AddResponseTypeAttributeCodeFixProviderIntegrationTest.cs (2)

64var project = GetProject(testMethod); 81private Project GetProject(string testMethod)

ApiActionsDoNotRequireExplicitModelValidationCheckCodeFixProviderTest.cs (2)

31var project = GetProject(testMethod); 46private Project GetProject(string testMethod)

ApiControllerFactsTest.cs (2)

34var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { source }); 129var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { testSource.Source });

Infrastructure\MvcDiagnosticAnalyzerRunner.cs (4)

22var project = CreateProjectWithReferencesInBinDir(GetType().Assembly, source); 27public static Project CreateProjectWithReferencesInBinDir(Assembly testAssembly, params string[] source) 33var project = DiagnosticProject.Create(testAssembly, source); 46public Task<Diagnostic[]> GetDiagnosticsAsync(Project project)

MvcFactsTest.cs (1)

223var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { testSource.Source });

SymbolApiConventionMatcherTest.cs (1)

556var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { testSource.Source });

SymbolApiResponseMetadataProviderTest.cs (1)

477var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { testSource.Source });

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixesAndRefactorings\FixAllHelper.cs (1)

15Project triggerProject)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ISolutionExtensions.cs (2)

38public static Project GetRequiredProject(this Solution solution, ProjectId projectId) 40var project = solution.GetProject(projectId);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (9)

17public static TLanguageService? GetLanguageService<TLanguageService>(this Project? project) where TLanguageService : class, ILanguageService 24public static TLanguageService GetRequiredLanguageService<TLanguageService>(this Project project) where TLanguageService : class, ILanguageService 33/// Gets extended host language services, which includes language services from <see cref="Project.LanguageServices"/>. 35public static HostLanguageServices GetExtendedLanguageServices(this Project project) 44public static string? TryGetAnalyzerConfigPathForProjectConfiguration(this Project project) 47public static string? TryGetAnalyzerConfigPathForDiagnosticConfiguration(this Project project, Diagnostic diagnostic) 53private static string? TryGetAnalyzerConfigPathForProjectOrDiagnosticConfiguration(Project project, Diagnostic? diagnostic) 101public static AnalyzerConfigDocument? TryGetExistingAnalyzerConfigDocumentAtPath(this Project project, string analyzerConfigPath) 109public static async Task<Compilation> GetRequiredCompilationAsync(this Project project, CancellationToken cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (2)

59foreach (var sourceProject in solution.Projects) 77var project = solution.GetProject(symbol.ContainingAssembly, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

25public Project Project => Document.Project;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

12public static bool CanApplyParseOptionChange(this Project project, ParseOptions oldOptions, ParseOptions newOptions)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

39var project = document.Project;

Remote\RemoteHostClientServiceFactoryTests.cs (1)

47var project = workspace.AddProject("proj", LanguageNames.CSharp);

Remote\SnapshotSerializationTests.cs (8)

49var project1 = solution.AddProject("Project", "Project.dll", LanguageNames.CSharp); 53var project2 = document1.Project.Solution.AddProject("Project2", "Project2.dll", LanguageNames.VisualBasic); 117var project = solution.AddProject("Project", "Project.dll", LanguageNames.CSharp); 139var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp); 476var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp); 501var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp); 520var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", NoCompilationConstants.LanguageName); 548var project = CreateWorkspace().CurrentSolution.AddProject("empty", "empty", LanguageNames.VisualBasic);

Services\AssetProviderTests.cs (2)

124var project = workspace.CurrentSolution.Projects.First(); 154var project = workspace.CurrentSolution.Projects.First();

Services\ServiceHubServicesTests.cs (42)

Services\SolutionServiceTests.cs (42)

Services\VisualStudioDiagnosticAnalyzerExecutorTests.cs (5)

51var project = workspace.CurrentSolution.Projects.First(); 84var project = workspace.CurrentSolution.Projects.First(); 164var project = workspace.CurrentSolution.Projects.First(); 204var project = workspace.CurrentSolution.Projects.First().AddAnalyzerReference(analyzerReference); 237var project = solution.GetProject(projectId);

CodeMetricsTestsBase.cs (2)

32protected Project CreateProject(string[] sources, string language = LanguageNames.CSharp) 74var project = CreateProject(sources, language);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixesAndRefactorings\FixAllHelper.cs (1)

15Project triggerProject)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ISolutionExtensions.cs (2)

38public static Project GetRequiredProject(this Solution solution, ProjectId projectId) 40var project = solution.GetProject(projectId);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (9)

17public static TLanguageService? GetLanguageService<TLanguageService>(this Project? project) where TLanguageService : class, ILanguageService 24public static TLanguageService GetRequiredLanguageService<TLanguageService>(this Project project) where TLanguageService : class, ILanguageService 33/// Gets extended host language services, which includes language services from <see cref="Project.LanguageServices"/>. 35public static HostLanguageServices GetExtendedLanguageServices(this Project project) 44public static string? TryGetAnalyzerConfigPathForProjectConfiguration(this Project project) 47public static string? TryGetAnalyzerConfigPathForDiagnosticConfiguration(this Project project, Diagnostic diagnostic) 53private static string? TryGetAnalyzerConfigPathForProjectOrDiagnosticConfiguration(Project project, Diagnostic? diagnostic) 101public static AnalyzerConfigDocument? TryGetExistingAnalyzerConfigDocumentAtPath(this Project project, string analyzerConfigPath) 109public static async Task<Compilation> GetRequiredCompilationAsync(this Project project, CancellationToken cancellationToken)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (2)

59foreach (var sourceProject in solution.Projects) 77var project = solution.GetProject(symbol.ContainingAssembly, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\SyntacticDocument.cs (1)

25public Project Project => Document.Project;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

12public static bool CanApplyParseOptionChange(this Project project, ParseOptions oldOptions, ParseOptions newOptions)