ToImmutableArray

CodeRefactoringRunner.cs (2)

157pair => FilterRefactorings(pair.Value, options).ToImmutableArray()); 234language => refactorings.Where(refactoring => refactoring.Metadata.Languages.Contains(language)).ToImmutableArray());

DiagnosticAnalyzerRunner.cs (1)

236pair => FilterAnalyzers(pair.Value, options).ToImmutableArray());

Model\ResourceGraph\ResourceGraphMapper.cs (1)

64ReferencedNames = resolvedNames.Distinct().OrderBy(n => n).ToImmutableArray(),

ServiceClient\DashboardClient.cs (1)

573InitialState: _resourceByName.Values.ToImmutableArray(),

ServiceClient\Partials.cs (6)

41HealthReports = HealthReports.Select(ToHealthReportViewModel).OrderBy(vm => vm.Name).ToImmutableArray(), 71.ToImmutableArray(); 78.ToImmutableArray(); 97.ToImmutableArray(); 104.ToImmutableArray(); 111.ToImmutableArray();

Controls\ResourceDetailsTests.cs (8)

31}.ToImmutableArray()); 78}.ToImmutableArray()); 115}.ToImmutableArray()); 162}.ToImmutableArray()); 199}.ToImmutableArray()); 246}.ToImmutableArray()); 283}.ToImmutableArray()); 330}.ToImmutableArray());

Shared\TestDashboardClient.cs (1)

87return Task.FromResult(new ResourceViewModelSubscription(_initialResources?.ToImmutableArray() ?? [], BuildSubscription(channel, cancellationToken)));

Model\ResourceViewModelTests.cs (1)

29var reports = healthStatusStrings?.Select<string?, HealthReportViewModel>((h, i) => new HealthReportViewModel(i.ToString(), h is null ? null : System.Enum.Parse<DiagnosticsHealthStatus>(h), null, null)).ToImmutableArray() ?? [];

Dashboard\ResourcePublisher.cs (1)

55InitialState: _snapshot.Select(r => r.Value.Snapshot).ToImmutableArray(),

Dcp\ResourceSnapshotBuilder.cs (1)

237return container.Spec.VolumeMounts?.Select(v => new VolumeSnapshot(v.Source, v.Target ?? "", v.Type, v.IsReadOnly)).ToImmutableArray() ?? [];

Devcontainers\Codespaces\CodespacesResourceUrlRewriterService.cs (1)

62Urls = transformedUrls.ToImmutableArray()

Health\HealthStatusTests.cs (1)

26var reports = healthStatusStrings?.Select<string?, HealthReportSnapshot>((h, i) => new HealthReportSnapshot(i.ToString(), h is null ? null : Enum.Parse<HealthStatus>(h), null, null)).ToImmutableArray() ?? [];

Program.cs (1)

376var sourceLinks = documents.Select(makeSourceLink).ToImmutableArray();

Program.cs (1)

966var releaseTrackingData = releaseTrackingFilesDataBuilder.ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

245var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\AddImports\AbstractAddImportsService.cs (1)

168var contextSpine = applicableContainer.GetAncestorsOrThis<SyntaxNode>().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.cs (2)

86.ToImmutableArray(); 98.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

156.ToImmutableArray();

InheritanceMargin\InheritanceMarginGlyphBenchmarks.cs (2)

134builder.Add(new InheritanceMarginTag(grouping.Key, grouping.ToImmutableArray())); 137_tags = builder.ToImmutableArray();

RegexClassifierBenchmarks.cs (1)

95return results.ToImmutableArray();

ClassificationBenchmarks.cs (1)

88return result.ToImmutableArray();

FormatterBenchmarks.cs (1)

70_ = formattedRoot.DescendantNodesAndSelf().ToImmutableArray();

NavigateToBenchmarks.cs (1)

229solution, grouping.ToImmutableArray(), priorityDocuments, "Syntax", service.KindsProvided, activeDocument: null,

Linker.Dataflow\ReflectionMethodBodyScanner.cs (2)

138arguments = methodParams.Skip(1).ToImmutableArray(); 143arguments = methodParams.ToImmutableArray();

DynamicallyAccessedMembersCodeFixProvider.cs (1)

64public sealed override ImmutableArray<string> FixableDiagnosticIds => SupportedDiagnostics.Select(dd => dd.Id).ToImmutableArray();

RequiresAssemblyFilesCodeFixProvider.cs (1)

25public sealed override ImmutableArray<string> FixableDiagnosticIds => SupportedDiagnostics.Select(dd => dd.Id).ToImmutableArray();

RequiresDynamicCodeCodeFixProvider.cs (1)

22public sealed override ImmutableArray<string> FixableDiagnosticIds => SupportedDiagnostics.Select(dd => dd.Id).ToImmutableArray();

RequiresUnreferencedCodeCodeFixProvider.cs (1)

22public sealed override ImmutableArray<string> FixableDiagnosticIds => SupportedDiagnostics.Select(dd => dd.Id).ToImmutableArray();

UnconditionalSuppressMessageCodeFixProvider.cs (1)

30DiagnosticId.RequiresDynamicCode }).Select(d => d.AsString()).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

DiagnosticAnalyzerRunner.cs (1)

86diags = diags.Where(d => d.Severity == DiagnosticSeverity.Error || analyzer.SupportedDiagnostics.Any(s => s.Id.Equals(d.Id))).ToImmutableArray();

DiagnosticVerifier.cs (1)

109diags = diags.Where(d => d.Severity == DiagnosticSeverity.Error || analyzer.SupportedDiagnostics.Any(s => s.Id.Equals(d.Id))).ToImmutableArray();

StartupAnalysisBuilder.cs (1)

37v => v.Value.ToImmutableArray()));

RouteEmbeddedLanguage\Infrastructure\RoutePatternParametersDetector.cs (1)

69ITypeSymbol typeSymbol => typeSymbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray().As<ISymbol>(),

RouteEmbeddedLanguage\Infrastructure\MarkupTestFile.cs (2)

216spans = builder.ToImmutableArray(); 223spans = dictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());

XmlComments\XmlComment.InheritDoc.cs (1)

231var typeParameterRefs = document.Descendants(DocumentationCommentXmlNames.TypeParameterReferenceElementName).ToImmutableArray();

Binding\BindingDiagnosticBag.cs (1)

85return new ReadOnlyBindingDiagnostic<TAssemblySymbol>(DiagnosticBag?.ToReadOnly(forceDiagnosticResolution) ?? default, DependenciesBag?.ToImmutableArray() ?? default);

CommandLine\CommonCompiler.cs (1)

244referenceDirectiveResolver = new ExistingReferencesResolver(commandLineReferenceResolver, resolved.ToImmutableArray());

Diagnostic\Diagnostic_SimpleDiagnostic.cs (1)

51_additionalLocations = additionalLocations?.ToImmutableArray() ?? SpecializedCollections.EmptyReadOnlyList<Location>();

DiagnosticAnalyzer\AnalysisResultBuilder.cs (2)

545var diagnostics = diagnosticsByAnalyzer.Value.Where(shouldInclude).ToImmutableArray(); 575var diagnostics = diagnosticsByAnalyzer.Value.Where(shouldInclude).ToImmutableArray();

DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (1)

395return _resolvedToOriginalPathMap.Select(x => (x.Value, x.Key)).ToImmutableArray();

DiagnosticAnalyzer\AnalyzerDriver.cs (2)

1474var actionsByKind = actionsByKindBuilder.Select(a => a.ToImmutableAndFree()).ToImmutableArray(); 1489builder.Add((analyzerAndActions.Key, analyzerAndActions.ToImmutableArray()));

DiagnosticAnalyzer\AnalyzerFileReference.cs (1)

423return builder.Distinct(ExtTypeComparer.Instance).ToImmutableArray();

DiagnosticAnalyzer\DiagnosticStartAnalysisScope.cs (1)

827return _codeBlockStartActions.OfType<CodeBlockStartAnalyzerAction<TLanguageKindEnum>>().ToImmutableArray();

DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (2)

119candidateMembers.Where(s => s.Kind == SymbolKind.NamedType).ToImmutableArray() : 120candidateMembers.Where(s => s.Kind != SymbolKind.NamedType).ToImmutableArray();

DocumentationCommentId.cs (2)

114return results.ToImmutableArray(); 192return results.ToImmutableArray();

Emit\CommonPEModuleBuilder.cs (1)

1061builder.Add(entry.Key, entry.Value.ToImmutableArray<ISymbolInternal>());

Operations\ControlFlowGraphBuilder.Context.cs (1)

37_currentImplicitInstance.AnonymousTypePropertyValues?.ToImmutableArray() ??

PEWriter\MetadataWriter.cs (1)

1912}).ToImmutableArray();

SourceGeneration\Nodes\NodeStateTable.cs (1)

652return new TableEntry(OneOrMany.Create(itemBuilder.ToImmutableArray()), s_allCachedEntries, anyRemoved: false);

SourceGeneration\Nodes\SharedInputNodes.cs (1)

24public static readonly InputNode<SyntaxTree> SyntaxTrees = new InputNode<SyntaxTree>(b => b.Compilation.SyntaxTrees.ToImmutableArray());

SourceGeneration\RunResults.cs (2)

51ImmutableInterlocked.InterlockedInitialize(ref _lazyDiagnostics, Results.Where(r => !r.Diagnostics.IsDefaultOrEmpty).SelectMany(r => r.Diagnostics).ToImmutableArray()); 69ImmutableInterlocked.InterlockedInitialize(ref _lazyGeneratedTrees, Results.Where(r => !r.GeneratedSources.IsDefaultOrEmpty).SelectMany(r => r.GeneratedSources.Select(g => g.SyntaxTree)).ToImmutableArray());

Text\TextChangeEventArgs.cs (1)

33this.Changes = changes.ToImmutableArray();

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (1)

1087customTags = arrayInitializer.ElementValues.Select(element => (string)element.ConstantValue.Value!).ToImmutableArray();

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

66var projectIds = diagnosticsToFix.Select(d => d.Key.Id).ToImmutableArray();

MetaAnalyzers\Fixers\DefineDiagnosticDescriptorArgumentsCorrectlyFix.cs (1)

48var additionalDocuments = context.Document.Project.AdditionalDocuments.ToImmutableArray();

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

106var additionalDocuments = project.AdditionalDocuments.ToImmutableArray();

MetaAnalyzers\SymbolIsBannedInAnalyzersAnalyzer.cs (1)

116return result.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());

src\RoslynAnalyzers\Microsoft.CodeAnalysis.BannedApiAnalyzers\Core\SymbolIsBannedAnalyzerBase.cs (1)

443.SelectMany(ExpandConstituentNamespaces).ToImmutableArray());

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

245var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\AddImports\AbstractAddImportsService.cs (1)

168var contextSpine = applicableContainer.GetAncestorsOrThis<SyntaxNode>().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.cs (2)

86.ToImmutableArray(); 98.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

156.ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataSymbolMapExtensions.cs (3)

70pointsToAnalysisResult[o.Kind, o.Syntax]).ToImmutableArray())); 93arguments.Select(o => pointsToAnalysisResult[o.Kind, o.Syntax]).ToImmutableArray(), 94arguments.Select(o => valueContentAnalysisResult[o.Kind, o.Syntax]).ToImmutableArray()));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AbstractLocationDataFlowOperationVisitor.cs (1)

124var keys = currentAnalysisData.Keys.ToImmutableArray();

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AnalysisEntityBasedPredicateAnalysisData.cs (1)

139var keys = CoreAnalysisData.Keys.ToImmutableArray();

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AnalysisEntityDataFlowOperationVisitor.cs (1)

94var keys = currentAnalysisData.Keys.ToImmutableArray();

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AnalysisEntityFactory.cs (1)

303CreateAbstractIndices(propertyReference.Arguments.Select(a => a.Value).ToImmutableArray()) :

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

245var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\AddImports\AbstractAddImportsService.cs (1)

168var contextSpine = applicableContainer.GetAncestorsOrThis<SyntaxNode>().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.cs (2)

86.ToImmutableArray(); 98.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

156.ToImmutableArray();

SymbolIsBannedAnalyzer.cs (1)

129return result.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());

SymbolIsBannedAnalyzerBase.cs (1)

443.SelectMany(ExpandConstituentNamespaces).ToImmutableArray());

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)

690var intersect = nextPragmaIds.Intersect(idsForPragma).ToImmutableArray();

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UpdateExpressionState.cs (3)

385if (foreachStatements.ToImmutableArray() is [TStatementSyntax childStatement] && 417var whenTrueStatements = whenTrue.ToImmutableArray(); 437var whenFalseStatements = whenFalse.ToImmutableArray();

src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (2)

119candidateMembers.Where(s => s.Kind == SymbolKind.NamedType).ToImmutableArray() : 120candidateMembers.Where(s => s.Kind != SymbolKind.NamedType).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

134var candidates = semanticModel.GetMemberGroup(expression, cancellationToken).OfType<IMethodSymbol>().ToImmutableArray();

src\Analyzers\Core\CodeFixes\ConflictMarkerResolution\AbstractConflictMarkerCodeFixProvider.cs (1)

403(d1, d2) => d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start).ToImmutableArray();

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.cs (2)

177arguments.Select(a => a.IsNamed)).ToImmutableArray(); 180arguments.Select(a => this.GenerateNameForArgument(document.SemanticModel, a, cancellationToken))).ToImmutableArray();

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (4)

126var typeParametersNames = TypeToGenerateIn.GetAllTypeParameters().Select(t => t.Name).ToImmutableArray(); 145(t, r) => CodeGenerationSymbolFactory.CreateParameterSymbol(r, t, name: "")).ToImmutableArray(); 158var remainingArguments = _arguments.Skip(argumentCount).ToImmutableArray(); 170var remainingParameterTypes = ParameterTypes.Skip(argumentCount).ToImmutableArray();

src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (2)

153var unavailableMemberNames = GetUnavailableMemberNames(typeToGenerateIn).ToImmutableArray(); 278var membersArray = members.ToImmutableArray();

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs (1)

46var result = capturedTypeParameters.Except<ITypeParameterSymbol>(availableTypeParameters, SymbolEqualityComparer.Default).ToImmutableArray();

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (2)

30.ToImmutableArray(); 36.ToImmutableArray();

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

80.SelectAsArray(group => (id: solution.GetRequiredDocument(group.Key!).Id, diagnostics: group.ToImmutableArray()));

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

834.ToImmutableArray();

src\Analyzers\Core\CodeFixes\SimplifyBooleanExpression\SimplifyConditionalCodeFixProvider.cs (1)

51diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start).ToImmutableArray(),

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

245var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\AddImports\AbstractAddImportsService.cs (1)

168var contextSpine = applicableContainer.GetAncestorsOrThis<SyntaxNode>().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.cs (2)

86.ToImmutableArray(); 98.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

156.ToImmutableArray();

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (1)

2368var result = dictionary.Count != interfaces.Length ? dictionary.Values.ToImmutableArray() : interfaces;

BoundTree\LengthBasedStringSwitchData.cs (1)

193: CreateAndRegisterStringJumpTable(group.ToImmutableArray(), stringJumpTables);

BoundTree\UnboundLambda.cs (1)

177parameterRefKinds.IsDefault ? Enumerable.Repeat(RefKind.None, parameterTypes.Length).ToImmutableArray() : parameterRefKinds,

Compilation\CSharpCompilation.cs (1)

4858return firstTree.Options.PreprocessorSymbolNames.ToImmutableArray();

Compilation\CSharpCompilation.UsingsFromOptionsAndDiagnostics.cs (1)

63boundUsings.Add(new NamespaceOrTypeAndUsingDirective(imported, null, dependencies: directiveDiagnostics.DependenciesBag.ToImmutableArray()));

FlowAnalysis\ControlFlowAnalysis.cs (1)

46((IEnumerable<SyntaxNode>)EntryPointsWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion, out _succeeded)).ToImmutableArray();

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (1)

278F.Switch(state, sections.ToImmutableArray()),

Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (1)

128return _temps.ToImmutableArray();

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

252var result = F.Switch(F.Local(cachedState), sections.ToImmutableArray());

SourceGeneration\CSharpGeneratorDriver.cs (1)

63=> new CSharpGeneratorDriver(parseOptions ?? CSharpParseOptions.Default, generators.ToImmutableArray(), optionsProvider ?? CompilerAnalyzerConfigOptionsProvider.Empty, additionalTexts.AsImmutableOrEmpty(), driverOptions);

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)

711elementSelector: grouping => grouping.ToImmutableArray());

Symbols\Source\SourceMemberContainerSymbol.cs (2)

823ImmutableInterlocked.InterlockedInitialize(ref _managedKindUseSiteDiagnostics, managedKindUseSiteInfo.Diagnostics?.ToImmutableArray() ?? ImmutableArray<DiagnosticInfo>.Empty); 824ImmutableInterlocked.InterlockedInitialize(ref _managedKindUseSiteDependencies, managedKindUseSiteInfo.Dependencies?.ToImmutableArray() ?? ImmutableArray<AssemblySymbol>.Empty);

Symbols\Source\SourceNamespaceSymbol.AliasesAndUsings.cs (2)

814getOrCreateUsingsBuilder(ref usings, globalUsingNamespacesOrTypes).Add(new NamespaceOrTypeAndUsingDirective(importedType, usingDirective, directiveDiagnostics.DependenciesBag.ToImmutableArray())); 1070compilation.RecordImportDependencies(usingDirective, diagnostics.DependenciesBag.ToImmutableArray());

Symbols\Source\SourcePropertySymbolBase.cs (1)

1704=> GetAttributes().Where(a => a.IsTargetAttribute(attributeDescription)).Cast<SourceAttributeData>().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (2)

53var leadingDirectives = statement.GetLeadingTrivia().Where(IsAnyCodeDirective).ToImmutableArray(); 54var closeBraceLeadingDirectives = block.CloseBraceToken.LeadingTrivia.Where(IsAnyCodeDirective).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Helpers\RemoveUnnecessaryImports\CSharpUnnecessaryImportsProvider.cs (1)

43return result.ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

115.ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AssignOutParametersAtStartCodeFixProvider.cs (2)

65.ToImmutableArray(); 68var originalStatements = generator.GetStatements(container).ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\MisplacedUsingDirectives\MisplacedUsingDirectivesCodeFixProvider.cs (1)

266var allUsings = usings.Concat(usingsFromNamespaces).ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\SimplifyPropertyPattern\CSharpSimplifyPropertyPatternCodeFixProvider.cs (1)

46.ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (1)

52.ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpIsAndCastCheckCodeFixProvider.cs (1)

70.ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (1)

204var leadingTrivia = firstMember.GetLeadingTrivia().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\NamedTypeGenerator.cs (1)

81.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\SemanticModelExtensions.cs (4)

63arguments.Select(a => a.NameColon != null)).ToImmutableArray(); 66arguments.Select(a => semanticModel.GenerateNameForArgument(a, cancellationToken))).ToImmutableArray(); 86arguments.Select(a => a.NameEquals != null)).ToImmutableArray(); 89arguments.Select(a => semanticModel.GenerateNameForArgument(a, cancellationToken))).ToImmutableArray();

AutomaticCompletion\AutomaticLineEnderCommandHandler_Helpers.cs (1)

572.ToImmutableArray();

Formatting\CSharpFormattingInteractionService.cs (1)

88return Task.FromResult(Formatter.GetFormattedTextChanges(parsedDocument.Root, [formattingSpan], document.Project.Solution.Services, options, cancellationToken).ToImmutableArray());

Classification\SemanticClassifierTests_TestMarkup.cs (3)

87var nonTestCodeSpans = actual.Where(s => s.ClassificationType != ClassificationTypeNames.TestCode).OrderBy((t1, t2) => t1.TextSpan.Start - t2.TextSpan.Start).ToImmutableArray(); 88var testCodeSpans = actual.Where(s => s.ClassificationType == ClassificationTypeNames.TestCode).OrderBy((t1, t2) => t1.TextSpan.Start - t2.TextSpan.Start).ToImmutableArray(); 104var actualOrdered = totalSpans.OrderBy(static (t1, t2) => t1.TextSpan.Start - t2.TextSpan.Start).ToImmutableArray();

Completion\ArgumentProviders\AbstractCSharpArgumentProviderTests`1.cs (1)

22return (argumentList, argumentList.Arguments.ToImmutableArray<SyntaxNode>());

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (1)

787.OrderBy(d => d.Id).ToImmutableArray();

src\VisualStudio\Core\Def\CodeCleanup\AbstractCodeCleanUpFixer_Helper.cs (2)

46enabledDiagnosticSets.ToImmutableArray(), 71enabledDiagnosticSets.ToImmutableArray(),

Emit\EditAndContinue\SymbolMatcherTests.cs (1)

87var members = builder.ToImmutableArray();

Attributes\AttributeTests_WellKnownAttributes.cs (3)

11437var exprs = tree.GetRoot().DescendantNodes().OfType<LambdaExpressionSyntax>().ToImmutableArray(); 11462var exprs = tree.GetRoot().DescendantNodes().OfType<LambdaExpressionSyntax>().ToImmutableArray(); 11493var exprs = tree.GetRoot().DescendantNodes().OfType<LambdaExpressionSyntax>().ToImmutableArray();

Diagnostics\DiagnosticAnalyzerTests.cs (1)

1708var files = compilation.SyntaxTrees.Select(t => t.FilePath).ToImmutableArray();

Diagnostics\GetDiagnosticsTests.cs (1)

968var group2 = semanticDiagnostics.Except(group1).ToImmutableArray();

FieldKeywordTests.cs (63)

FirstClassSpanTests.cs (1)

2857var casts = tree.GetRoot().DescendantNodes().OfType<CastExpressionSyntax>().ToImmutableArray();

FlowAnalysis\FlowTests.cs (1)

5842var declarations = tree.GetRoot().DescendantNodes().OfType<PropertyDeclarationSyntax>().ToImmutableArray();

PartialEventsAndConstructorsTests.cs (4)

1988var eventDefs = tree.GetRoot().DescendantNodes().OfType<VariableDeclaratorSyntax>().ToImmutableArray(); 1991var eventImpls = tree.GetRoot().DescendantNodes().OfType<EventDeclarationSyntax>().ToImmutableArray(); 2031var ctors = tree.GetRoot().DescendantNodes().OfType<ConstructorDeclarationSyntax>().ToImmutableArray(); 2099var ctors = tree.GetRoot().DescendantNodes().OfType<ConstructorDeclarationSyntax>().ToImmutableArray();

BraceCompletion\AbstractCurlyBraceOrBracketCompletionService.cs (1)

270var textChanges = result.GetTextChanges(cancellationToken).ToImmutableArray();

ChangeSignature\CSharpChangeSignatureService.cs (1)

902.ToImmutableArray();

CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (1)

370var namespaceDecls = node.AncestorsAndSelf().OfType<BaseNamespaceDeclarationSyntax>().ToImmutableArray();

CodeRefactorings\SyncNamespace\CSharpSyncNamespaceCodeRefactoringProvider.cs (1)

35.OfType<BaseNamespaceDeclarationSyntax>().ToImmutableArray();

Completion\CompletionProviders\TupleNameCompletionProvider.cs (1)

62.ToImmutableArray();

ConvertAnonymousType\CSharpConvertAnonymousTypeToTupleCodeRefactoringProvider.cs (1)

42var originalSeparators = declarators.GetSeparators().ToImmutableArray();

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (2)

1054select (GetDeclaredSymbol(oldModel.RequiredModel, oldVariable, cancellationToken), GetDeclaredSymbol(newModel.RequiredModel, newVariable, cancellationToken))).ToImmutableArray()); 3052: OneOrMany.Create(declaration.Variables.Select(static v => (SyntaxNode?)v.Initializer?.Value).WhereNotNull().ToImmutableArray());

EditAndContinue\DeclarationBody\TopLevelCodeDeclarationBody.cs (1)

53=> OneOrMany.Create(GlobalStatements.ToImmutableArray<SyntaxNode>());

ExtractMethod\CSharpSelectionResult.cs (1)

137=> exitPoints.OfType<ReturnStatementSyntax>().ToImmutableArray().CastArray<StatementSyntax>();

ImplementInterface\AbstractChangeImplementationCodeRefactoringProvider.cs (1)

86s => s.ContainingType).Distinct().ToImmutableArray();

InheritanceMargin\CSharpInheritanceMarginService.cs (1)

62return builder.ToImmutableArray();

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

80context.RegisterRefactorings(refactorings.ToImmutableArray(), context.Span);

QuickInfo\CSharpSemanticQuickInfoProvider.cs (1)

218}).ToImmutableArray();

QuickInfo\CSharpSyntacticQuickInfoProvider.cs (1)

154.ToImmutableArray();

QuickInfo\OnTheFlyDocsUtilities.cs (2)

24}).ToImmutableArray(); 30}).ToImmutableArray();

SignatureHelp\InvocationExpressionSignatureHelpProvider.cs (1)

91.ToImmutableArray()

src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

115.ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AssignOutParametersAtStartCodeFixProvider.cs (2)

65.ToImmutableArray(); 68var originalStatements = generator.GetStatements(container).ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\MisplacedUsingDirectives\MisplacedUsingDirectivesCodeFixProvider.cs (1)

266var allUsings = usings.Concat(usingsFromNamespaces).ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\SimplifyPropertyPattern\CSharpSimplifyPropertyPatternCodeFixProvider.cs (1)

46.ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (1)

52.ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\UsePatternMatching\CSharpIsAndCastCheckCodeFixProvider.cs (1)

70.ToImmutableArray();

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (1)

204var leadingTrivia = firstMember.GetLeadingTrivia().ToImmutableArray();

Structure\Providers\FileScopedNamespaceDeclarationStructureProvider.cs (1)

28var externsAndUsings = Enumerable.Union<SyntaxNode>(fileScopedNamespaceDeclaration.Externs, fileScopedNamespaceDeclaration.Usings).ToImmutableArray();

Semantics\LambdaTests.cs (14)

Semantics\LocalFunctionTests.cs (4)

2589var exprs = tree.GetRoot().DescendantNodes().OfType<LocalFunctionStatementSyntax>().ToImmutableArray(); 6491var exprs = tree.GetRoot().DescendantNodes().OfType<TypeOfExpressionSyntax>().Select(n => n.Type).ToImmutableArray(); 6538var exprs = tree.GetRoot().DescendantNodes().OfType<SizeOfExpressionSyntax>().Select(n => n.Type).ToImmutableArray(); 6556ToImmutableArray();

Semantics\NameOfTests.cs (4)

1020.ToImmutableArray(); 1094.ToImmutableArray(); 1177.ToImmutableArray(); 1258.ToImmutableArray();

Semantics\NullableReferenceTypesTests.cs (5)

62883var declarators = syntaxTree.GetRoot().DescendantNodes().OfType<AnonymousObjectMemberDeclaratorSyntax>().ToImmutableArray(); 161309var arms = syntaxTree.GetRoot().DescendantNodes().OfType<SwitchExpressionArmSyntax>().ToImmutableArray(); 161313var identifiers = unreachableArm.DescendantNodes().OfType<IdentifierNameSyntax>().ToImmutableArray(); 161355var sections = syntaxTree.GetRoot().DescendantNodes().OfType<SwitchSectionSyntax>().ToImmutableArray(); 161359var identifiers = unreachableSection.DescendantNodes().OfType<IdentifierNameSyntax>().ToImmutableArray();

Semantics\OverloadResolutionPerfTests.cs (1)

1060var exprs = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().ToImmutableArray();

SourceGeneration\GeneratorDriverFuzzTests.cs (1)

315driver1 = driver1.ReplaceAdditionalTexts(editedInputs.ToImmutableArray<AdditionalText>());

SourceGeneration\GeneratorDriverTests.cs (1)

2077driver = driver.RemoveAdditionalTexts(texts.ToImmutableArray());

Symbols\SymbolEqualityTests.cs (1)

965Select(op => op.Symbol.GetSymbol<LambdaSymbol>()).ToImmutableArray();

Diagnostics\LineSpanDirectiveTests.cs (2)

246var actualVisibility = textB.Lines.Select(line => treeB.GetLineVisibility(line.Start)).ToImmutableArray(); 468return tree.GetLineMappings().Select(mapping => mapping.ToString()!).ToImmutableArray();

TestAttributesVisitor.cs (1)

164var arguments = attribute.ConstructorArguments.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (2)

53var leadingDirectives = statement.GetLeadingTrivia().Where(IsAnyCodeDirective).ToImmutableArray(); 54var closeBraceLeadingDirectives = block.CloseBraceToken.LeadingTrivia.Where(IsAnyCodeDirective).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Helpers\RemoveUnnecessaryImports\CSharpUnnecessaryImportsProvider.cs (1)

43return result.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\NamedTypeGenerator.cs (1)

81.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\SemanticModelExtensions.cs (4)

63arguments.Select(a => a.NameColon != null)).ToImmutableArray(); 66arguments.Select(a => semanticModel.GenerateNameForArgument(a, cancellationToken))).ToImmutableArray(); 86arguments.Select(a => a.NameEquals != null)).ToImmutableArray(); 89arguments.Select(a => semanticModel.GenerateNameForArgument(a, cancellationToken))).ToImmutableArray();

CodeActions\CodeActionEditHandlerService.cs (4)

205var projectChanges = changes.GetProjectChanges().ToImmutableArray(); 228var changedAdditionalDocuments = projectChange.GetChangedAdditionalDocuments().ToImmutableArray(); 229var changedDocuments = projectChange.GetChangedDocuments(onlyGetDocumentsWithTextChanges: true).ToImmutableArray(); 230var changedAnalyzerConfigDocuments = projectChange.GetChangedAnalyzerConfigDocuments().ToImmutableArray();

CommentSelection\ToggleLineCommentCommandHandler.cs (1)

86span => GetLinesFromSelectedSpan(span).ToImmutableArray());

EditAndContinue\ActiveStatementTrackingService.cs (1)

198var openDocumentIds = _workspace.GetOpenDocumentIds().ToImmutableArray();

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

36var analyzerReferences = RoslynEnumerableExtensions.DistinctBy(projectsInScope.SelectMany(p => p.AnalyzerReferences), a => a.Id).ToImmutableArray();

InlineRename\AbstractEditorInlineRenameService.InlineRenameLocationSet.cs (1)

32.ToImmutableArray();

InlineRename\InlineRenameSession.OpenTextBufferManager.cs (3)

357.Select(document => (document, conflictResolution.GetReplacements(document.Id).Where(r => GetRenameSpanKind(r.Kind) != RenameSpanKind.None).ToImmutableArray())) 358.ToImmutableArray(); 443.ToImmutableArray();

IntelliSense\AsyncCompletion\CompletionSource.cs (1)

444session.Properties[ExcludedCommitCharacters] = excludedCommitCharactersMap.Keys.ToImmutableArray();

NavigationBar\NavigationBarController.cs (1)

255.ToImmutableArray();

Suggestions\SuggestedActionsSource_Async.cs (1)

220var convertedSets = filteredSets.Select(s => ConvertToSuggestedActionSet(s, document)).WhereNotNull().ToImmutableArray();

NavigateTo\AbstractNavigateToTests.cs (1)

206itemDisplay.GetNameMatchRuns("").Select(s => s.ToTextSpan()).ToImmutableArray());

ObsoleteSymbol\AbstractObsoleteSymbolTests.cs (1)

29var documents = project.Documents.ToImmutableArray();

ReassignedVariable\AbstractReassignedVariableTests.cs (1)

28var documents = project.Documents.ToImmutableArray();

Squiggles\SquiggleUtilities.cs (1)

44var spans = tagger.GetTags(snapshot.GetSnapshotSpanCollection()).ToImmutableArray();

CodeFixes\CodeFixServiceTests.cs (1)

855var txtDocumentCodeFixTitles = txtDocumentCodeFixes.Select(s => s.Fixes.Single().Action.Title).ToImmutableArray();

CodeFixes\ExtensionOrderingTests.cs (2)

130var expectedOrder = ExtensionOrderer.Order(langProviders).Select(lazy => lazy.Value).ToImmutableArray(); 137var actualOrder = codeFixPriorityMap.OrderBy(kvp => kvp.Value).Select(kvp => kvp.Key).ToImmutableArray();

CodeRefactorings\CodeRefactoringServiceTest.cs (2)

176var txtRefactoringTitles = txtRefactorings.Select(s => s.CodeActions.Single().action.Title).ToImmutableArray(); 215var editorConfigRefactoringTitles = editorConfigRefactorings.Select(s => s.CodeActions.Single().action.Title).ToImmutableArray();

Diagnostics\DiagnosticAnalyzerServiceTests.cs (1)

438var analyzerReference = new AnalyzerImageReference(analyzers.ToImmutableArray());

InheritanceMargin\InheritanceMarginTests.cs (5)

121var sortedActualItems = actualItems.OrderBy(item => item.LineNumber).ToImmutableArray(); 122var sortedExpectedItems = memberItems.OrderBy(item => item.LineNumber).ToImmutableArray(); 140.ToImmutableArray(); 164var actualDocumentSpans = actualTarget.DefinitionItem.SourceSpans.OrderBy(documentSpan => documentSpan.SourceSpan.Start).ToImmutableArray(); 165var expectedDocumentSpans = expectedTarget.DocumentSpans.OrderBy(documentSpan => documentSpan.SourceSpan.Start).ToImmutableArray();

Snippets\RoslynLSPSnippetConvertTests.cs (1)

462var placeholders = spans.Select(span => span.Start).ToImmutableArray();

SuggestedActions\SuggestedActionSourceProviderTests.cs (1)

22.ToImmutableArray();

Diagnostics\DiagnosticServiceTests.vb (1)

2023Dim analyzerReference = New AnalyzerImageReference(analyzers.ToImmutableArray())

Diagnostics\NamingStyles\NamingStyleTests.vb (1)

27Assert.Equal(expectedName, namingStyle.CreateName(words.ToImmutableArray()))

Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

Internal\Editor\FSharpEditorFormattingService.cs (4)

82return changes?.ToImmutableArray() ?? []; 88return changes?.ToImmutableArray() ?? []; 94return changes?.ToImmutableArray() ?? []; 100return changes?.ToImmutableArray() ?? [];

Remote\RazorServiceDescriptorsWrapper.cs (1)

53return options.Converters.ToImmutableArray();

GeneratorExtensions.cs (1)

35public static ImmutableArray<(string Key, string Value)> GetHostOutputs(this GeneratorRunResult runResult) => runResult.HostOutputs.ToImmutableArray().SelectAsArray(a => (a.Key, a.Value.ToString() ?? ""));

External\ConversionHelpers.cs (1)

26.ToImmutableArray();

Internal\DescriptionService.cs (1)

93return builder.ToImmutableArray();

Internal\XamlDiagnosticSource.cs (1)

29var result = diagnostics.Select(e => DiagnosticData.Create(e, document)).ToImmutableArray();

AddImport\AbstractAddImportFeatureService.cs (1)

575.ToImmutableArray();

ChangeSignature\SignatureChange.cs (2)

107var originalListWithoutRemovedOrAdded = originalListOfParameters.Where(updatedListOfParameters.Contains).ToImmutableArray(); 108var updatedListWithoutRemovedOrAdded = updatedListOfParameters.Where(originalListOfParameters.Contains).ToImmutableArray();

CodeFixes\Service\CodeFixService.cs (1)

503var allFixers = fixerToRangesAndDiagnostics.Keys.ToImmutableArray();

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (2)

159var result = bag.ToImmutableArray(); 307.ToImmutableArray();

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

111var trivia = startToken.LeadingTrivia.ToImmutableArray();

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

139var attributeRemoveFixesForTree = removeSuppressionFixesForTree.OfType<AttributeRemoveAction>().ToImmutableArray();

CodeFixes\Suppression\WrapperCodeFixProvider.cs (2)

25var documentDiagnostics = diagnostics.Where(d => d.Location.IsInSource).ToImmutableArray(); 32var projectDiagnostics = diagnostics.Where(d => !d.Location.IsInSource).ToImmutableArray();

CodeLens\CodeLensReferencesService.cs (1)

271return result.OfType<ReferenceMethodDescriptor>().ToImmutableArray();

CodeRefactorings\CodeRefactoringService.cs (1)

191var orderedProviders = GetProviders(document).Where(p => priority == null || p.RequestPriority == priority).ToImmutableArray();

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (1)

184var typeNameParts = GetTypeNamePartsForNestedTypeNode(typeNode).ToImmutableArray();

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

96.ToImmutableArray();

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

52var itemsBefore = childNodes.Take(index).ToImmutableArray(); 53var itemsAfter = childNodes.Skip(index + 1).ToImmutableArray();

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (1)

475.ToImmutableArray();

Completion\CompletionService_GetCompletions.cs (2)

106var exclusiveContexts = triggeredContexts.Where(t => t.IsExclusive).ToImmutableArray(); 114var augmentingProviders = providers.Except(triggeredProviders).ToImmutableArray();

Completion\Providers\AbstractMemberInsertingCompletionProvider.cs (1)

54var changesArray = changes.ToImmutableArray();

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (2)

257.ToImmutableArray(); 323var originalProperties = anonymousType.GetMembers().OfType<IPropertySymbol>().ToImmutableArray();

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (1)

74.ToImmutableArray();

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (3)

347var afterPlaceholderArguments = arguments.Skip(placeholderIndex + 1).ToImmutableArray(); 348var unnamedArguments = afterPlaceholderArguments.TakeWhile(a => !syntaxFacts.IsNamedArgument(a)).ToImmutableArray(); 349var namedAndUnnamedArguments = afterPlaceholderArguments.Skip(unnamedArguments.Length).ToImmutableArray();

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (3)

86.ToImmutableArray(); 289.ToImmutableArray(); 863field.Name)))).ToImmutableArray();

EmbeddedLanguages\AbstractEmbeddedLanguageFeatureService.cs (2)

58var orderedFeatureProviders = ExtensionOrderer.Order(allServices).Where(c => c.Metadata.Languages.Contains(languageName)).ToImmutableArray(); 78var languageIdentifiers = _identifierToServices.Keys.ToImmutableArray();

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

47_analyzerProviders = analyzerProviders.GroupBy(kv => kv.Metadata.Name).ToImmutableDictionary(g => g.Key, g => g.ToImmutableArray());

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

264var reanalyzers = workItem.SpecificAnalyzers.ToImmutableArray();

ExtractMethod\MethodExtractor.Analyzer.cs (1)

149var allVariableInfos = symbolMap.Values.Order().ToImmutableArray();

FindUsages\AbstractFindUsagesService_FindImplementations.cs (1)

154var overrides = result.Where(s => s.IsOverride).ToImmutableArray();

FullyQualify\AbstractFullyQualifyService.cs (2)

101.ToImmutableArray(); 137.ToImmutableArray();

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.State.cs (1)

61var mappedMembers = selectedMembers.Select(m => TryMapToWritableInstanceFieldOrProperty(service, m, cancellationToken)).Distinct().ToImmutableArray();

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (1)

104.ToImmutableArray();

GenerateFromMembers\GenerateFromMembersHelpers.cs (1)

35d => semanticModel.GetDeclaredSymbol(d, cancellationToken)).WhereNotNull().ToImmutableArray();

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

599var membersArray = members.ToImmutableArray();

GenerateType\AbstractGenerateTypeService.GenerateNamedType.cs (1)

152(t, r) => CodeGenerationSymbolFactory.CreateParameterSymbol(r, t, name: "")).ToImmutableArray();

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (2)

615return builder.ToImmutableArray(); 650return builder.ToImmutableArray();

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (2)

271.ToImmutableArray(); 303.ToImmutableArray();

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (2)

358.ToImmutableArray(); 450.ToImmutableArray();

IntroduceParameter\IntroduceParameterDocumentRewriter.cs (1)

229var validParameters = _methodSymbol.Parameters.Intersect(expressionParameterMap.Values).ToImmutableArray();

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (1)

361.ToImmutableArray();

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (1)

477var statementsAfterIf = statements.Skip(index + 1).ToImmutableArray();

LanguageServices\SymbolDisplayService\AbstractSymbolDisplayService.AbstractSymbolDescriptionBuilder.cs (1)

255var captures = analysis.CapturedInside.Except(analysis.VariablesDeclared).ToImmutableArray();

MoveToNamespace\AbstractMoveToNamespaceService.cs (2)

197.ToImmutableArray(); 207.ToImmutableArray();

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

118var groups = documentKeys.GroupBy(d => d.Project).ToImmutableArray();

NavigateTo\NavigateToSearcher.cs (1)

492.ToImmutableArray());

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

334metadataReferences: project.MetadataReferences.ToImmutableArray()); // TODO: Read references from PDB info: https://github.com/dotnet/roslyn/issues/55834

PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (1)

85? containingType.GetBaseTypes().ToImmutableArray()

QuickInfo\QuickInfoServiceWithProviders.cs (1)

40.ToImmutableArray();

Shared\Utilities\AnnotatedSymbolMapping.cs (1)

106elementSelector: (kvp) => kvp.Value.ToImmutableArray());

SignatureHelp\CommonSignatureHelpUtilities.cs (2)

34var argumentNames = getArgumentNames(argumentList).ToImmutableArray(); 174.ToImmutableArray()

Snippets\SnippetProviders\AbstractSnippetProvider.cs (1)

108var changesArray = changes.ToImmutableArray();

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)

690var intersect = nextPragmaIds.Intersect(idsForPragma).ToImmutableArray();

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UpdateExpressionState.cs (3)

385if (foreachStatements.ToImmutableArray() is [TStatementSyntax childStatement] && 417var whenTrueStatements = whenTrue.ToImmutableArray(); 437var whenFalseStatements = whenFalse.ToImmutableArray();

src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

134var candidates = semanticModel.GetMemberGroup(expression, cancellationToken).OfType<IMethodSymbol>().ToImmutableArray();

src\Analyzers\Core\CodeFixes\ConflictMarkerResolution\AbstractConflictMarkerCodeFixProvider.cs (1)

403(d1, d2) => d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start).ToImmutableArray();

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.cs (2)

177arguments.Select(a => a.IsNamed)).ToImmutableArray(); 180arguments.Select(a => this.GenerateNameForArgument(document.SemanticModel, a, cancellationToken))).ToImmutableArray();

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (4)

126var typeParametersNames = TypeToGenerateIn.GetAllTypeParameters().Select(t => t.Name).ToImmutableArray(); 145(t, r) => CodeGenerationSymbolFactory.CreateParameterSymbol(r, t, name: "")).ToImmutableArray(); 158var remainingArguments = _arguments.Skip(argumentCount).ToImmutableArray(); 170var remainingParameterTypes = ParameterTypes.Skip(argumentCount).ToImmutableArray();

src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (2)

153var unavailableMemberNames = GetUnavailableMemberNames(typeToGenerateIn).ToImmutableArray(); 278var membersArray = members.ToImmutableArray();

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs (1)

46var result = capturedTypeParameters.Except<ITypeParameterSymbol>(availableTypeParameters, SymbolEqualityComparer.Default).ToImmutableArray();

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (2)

30.ToImmutableArray(); 36.ToImmutableArray();

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

80.SelectAsArray(group => (id: solution.GetRequiredDocument(group.Key!).Id, diagnostics: group.ToImmutableArray()));

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

834.ToImmutableArray();

src\Analyzers\Core\CodeFixes\SimplifyBooleanExpression\SimplifyConditionalCodeFixProvider.cs (1)

51diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start).ToImmutableArray(),

src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (2)

119candidateMembers.Where(s => s.Kind == SymbolKind.NamedType).ToImmutableArray() : 120candidateMembers.Where(s => s.Kind != SymbolKind.NamedType).ToImmutableArray();

StackTraceExplorer\StackFrameLocalMethodResolver.cs (1)

41.ToImmutableArray();

StackTraceExplorer\StackFrameMethodSymbolResolver.cs (1)

28.ToImmutableArray();

SyncNamespaces\AbstractSyncNamespacesService.cs (1)

173.ToImmutableArray();

Testing\AbstractTestMethodFinder.cs (1)

100return testMethods.ToImmutableArray();

UnusedReferences\ProjectAssets\ProjectAssetsReader.cs (2)

65.ToImmutableArray(); 177.ToImmutableArray();

UnusedReferences\UnusedReferencesRemover.cs (1)

71.ToDictionary(group => group.Key, group => group.ToImmutableArray());

ValueTracking\ValueTracker.OperationCollector.cs (1)

188.ToImmutableArray();

Wrapping\AbstractCodeActionComputer.cs (2)

227var tokens = leftTokenToTrailingTrivia.Keys.Concat(rightTokenToLeadingTrivia.Keys).Distinct().ToImmutableArray(); 282var wrappingActions = group.WrappingActions.WhereNotNull().ToImmutableArray();

EditAndContinue\ActiveStatementsDescription.cs (1)

48documentPathMap: oldDocumentMap.ToImmutableDictionary(e => e.Key, e => e.Value.OrderBy(ActiveStatementsMap.Comparer).ToImmutableArray()),

EditAndContinue\EditAndContinueWorkspaceTestBase.cs (1)

232return (result.ModuleUpdates, result.Diagnostics.OrderBy(d => d.ProjectId.DebugName).ToImmutableArray().ToDiagnosticData(solution));

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (1)

137: (from project in solution.Projects from documentId in project.DocumentIds select documentId).ToImmutableArray();

Interactive\Core\InteractiveHost.Service.cs (2)

422var newSourcePaths = globals.SourcePaths.ToImmutableArray(); 423var newReferencePaths = globals.ReferencePaths.ToImmutableArray();

HostWorkspace\LanguageServerWorkspaceFactory.cs (1)

46.ToImmutableArray();

HostWorkspace\LoadedProject.cs (2)

170}).Where(static cr => cr.Reference is not null).ToImmutableArray(); 188}).Where(static cr => cr.FilePath is not null).ToImmutableArray();

HostWorkspace\ProjectDependencyHelper.cs (1)

113.ToImmutableDictionary(g => g.Key, g => g.ToImmutableArray(), StringComparer.OrdinalIgnoreCase);

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

126.ToImmutableArray();

Services\LspExtractClassOptionsService.cs (1)

35var memberAnalysisResults = symbolsToUse.Select(m => new ExtractClassMemberAnalysisResult(m, makeAbstract: false)).ToImmutableArray();

Extensions\Extensions.cs (3)

78.ToImmutableArray(); 186var projects = solution.Projects.Where(project => project.FilePath == projectIdentifier.DocumentUri.ParsedUri.LocalPath).ToImmutableArray(); 197var additionalDocuments = documentIds.Select(solution.GetAdditionalDocument).WhereNotNull().ToImmutableArray();

Extensions\ProtocolConversions.Diagnostics.cs (1)

75return diagnosticsBuilder.ToImmutableArray();

Features\UnifiedSuggestions\UnifiedSuggestedActionsSource.cs (2)

293var nonSuppressionActions = actions.Where(a => !IsTopLevelSuppressionAction(a.OriginalCodeAction)).ToImmutableArray(); 297!IsBulkConfigurationAction(a.OriginalCodeAction)).ToImmutableArray();

Handler\Completion\CompletionHandler.cs (1)

240.ToImmutableArray();

Handler\Diagnostics\AbstractWorkspacePullDiagnosticsHandler.cs (1)

95foreach (var category in _categoryToLspChanged.Keys.ToImmutableArray())

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

135var result = sources.ToImmutableArray();

Handler\Diagnostics\DiagnosticsPullCache.cs (1)

94foreach (var key in diagnosticData.Properties.Keys.ToImmutableArray().Sort())

Handler\Diagnostics\Public\PublicWorkspacePullDiagnosticsHandler.cs (1)

95}).ToImmutableArray();

Handler\Diagnostics\WorkspacePullDiagnosticHandler.cs (1)

58=> diagnosticsParams.PreviousResults?.Where(d => d.PreviousResultId != null).Select(d => new PreviousPullResult(d.PreviousResultId!, d.TextDocument!)).ToImmutableArray();

Handler\InlineCompletions\InlineCompletionsHandler.cs (1)

194?.ToImmutableArray() ?? [];

Handler\InlineCompletions\XmlSnippetParser.CodeSnippet.cs (2)

81return codeSnippetsElement.Elements().Where(e => e.Name.LocalName.Equals("CodeSnippet", StringComparison.OrdinalIgnoreCase)).ToImmutableArray(); 112return ReadCodeSnippetElements(document)?.Select(element => new CodeSnippet(element)).ToImmutableArray();

Handler\SemanticTokens\SemanticTokensSchema.cs (1)

114.ToImmutableArray();

Handler\SpellCheck\WorkspaceSpellCheckHandler.cs (1)

29=> requestParams.PreviousResults?.Where(d => d.PreviousResultId != null).Select(d => new PreviousPullResult(d.PreviousResultId!, d.TextDocument!)).ToImmutableArray();

Completion\CompletionFeaturesTests.cs (1)

714var myClassItems = completionResult.Items.Where(i => i.Label == "MyClass").ToImmutableArray();

Diagnostics\PullDiagnosticTests.cs (1)

2017var previousResultIds = previousResults.Select(param => param.resultId).ToImmutableArray();

MapCode\MapCodeTests.cs (1)

39return newText.GetTextChanges(text).ToImmutableArray();

SpellCheck\SpellCheckTests.cs (1)

578.ToImmutableArray();

Workspaces\LspWorkspaceManagerTests.cs (4)

676var oldClassDeclarations = originalRoot.DescendantNodes().Where(n => syntaxFacts.IsClassDeclaration(n)).ToImmutableArray(); 677var newClassDeclarations = newRoot.DescendantNodes().Where(n => syntaxFacts.IsClassDeclaration(n)).ToImmutableArray(); 686var oldMethodDeclarations = originalRoot.DescendantNodes().Where(n => syntaxFacts.IsMethodLevelMember(n)).ToImmutableArray(); 687var newMethodDeclarations = newRoot.DescendantNodes().Where(n => syntaxFacts.IsMethodLevelMember(n)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

245var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\AddImports\AbstractAddImportsService.cs (1)

168var contextSpine = applicableContainer.GetAncestorsOrThis<SyntaxNode>().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.cs (2)

86.ToImmutableArray(); 98.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

156.ToImmutableArray();

DeclarePublicApiAnalyzer.Impl.cs (1)

510var nestedNamespaceOrTypeMembers = containingSymbol.GetMembers().OfType<INamespaceOrTypeSymbol>().ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

CompilationFactory.cs (1)

88.ToImmutableArray();

CompilationOptionsReader.cs (1)

480return options.ToImmutableArray();

CSharpRebuildTests.cs (3)

39.ToImmutableArray(); 40var references = original.References.ToImmutableArray(); 41var rebuild = compilationFactory.CreateCompilation(sources, original.References.ToImmutableArray());

RoundTripUtil.cs (1)

95original.References.ToImmutableArray());

Services\ExtensionMethodImportCompletion\RemoteExtensionMethodImportCompletionService.cs (1)

51.WhereNotNull().ToImmutableArray();

VisualStudioMefHostServices.cs (2)

51return _exportProvider.GetExports<TExtension, TMetadata>().ToImmutableArray(); 67_exportProvider.GetExports<TExtension>().ToImmutableArray());

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

Compilation\CompilationTestDataExtensions.cs (1)

45return data.Methods.Where(m => !m.Key.IsImplicitlyDeclared).ToImmutableArray();

CompilationVerifier.cs (2)

612dependencyList.ToImmutableArray(), 1048.ToImmutableArray();

Diagnostics\CommonDiagnosticAnalyzers.cs (1)

1258return _controlFlowGraphMapOpt.Values.OrderBy(flowGraphAndSymbol => flowGraphAndSymbol.Graph.OriginalOperation.Syntax.SpanStart).ToImmutableArray();

Diagnostics\DiagnosticDescription.cs (1)

481specifiers = builder.ToImmutableArray();

TargetFrameworkUtil.cs (1)

429references = ((IEnumerable<PortableExecutableReference>)obj).ToImmutableArray();

Collections\TemporaryArrayTests.cs (2)

92array.AddRange(Enumerable.Range(0, TemporaryArray<int>.TestAccessor.InlineCapacity + 1).ToImmutableArray()); 108array.AddRange(Enumerable.Range(0, addedItems).ToImmutableArray());

Analysis\FlowAnalysis\ControlFlowAnalysis.vb (2)

44DirectCast(EntryPointsWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo, _succeeded), IEnumerable(Of SyntaxNode)).ToImmutableArray()) 58DirectCast(ExitPointsWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo), IEnumerable(Of SyntaxNode)).ToImmutableArray())

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Helpers\RemoveUnnecessaryImports\VisualBasicUnnecessaryImportsProvider.vb (1)

68Return unnecessaryImports.ToImmutableArray()

src\Analyzers\VisualBasic\CodeFixes\RemoveUnnecessaryCast\VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb (1)

103document, currentCastNodes.ToImmutableArray(),

CommandLineTests.vb (2)

2523Dim references = parsedArgs.ResolveMetadataReferences(metadataResolver).ToImmutableArray() 2539Dim references = parsedArgs.ResolveMetadataReferences(metadataResolver).ToImmutableArray()

ChangeSignature\VisualBasicChangeSignatureService.vb (1)

626Return node.GetLeadingTrivia().ToImmutableArray()

SplitOrMergeIfStatements\VisualBasicIfLikeStatementGenerator.vb (2)

100Return AddIfNotNull(ifBlock.ElseIfBlocks, ifBlock.ElseBlock).ToImmutableArray() 105Return AddIfNotNull(nextElseIfBlocks, ifBlock.ElseBlock).ToImmutableArray()

src\Analyzers\VisualBasic\CodeFixes\RemoveUnnecessaryCast\VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb (1)

103document, currentCastNodes.ToImmutableArray(),

Diagnostics\DiagnosticAnalyzerTests.AllInOne.vb (3)

20Dim options = New AnalyzerOptions({DirectCast(New TestAdditionalText(), AdditionalText)}.ToImmutableArray()) 46Dim options = New AnalyzerOptions({CType(new TestAdditionalText(), AdditionalText)}.ToImmutableArray()) 55Dim options = New AnalyzerOptions(additionalTexts.ToImmutableArray())

CompilationTestUtils.vb (1)

978Return DumpAllDiagnostics(allDiagnostics.ToImmutableArray(), suppressInfos)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Helpers\RemoveUnnecessaryImports\VisualBasicUnnecessaryImportsProvider.vb (1)

68Return unnecessaryImports.ToImmutableArray()

CodeActions\Operations\ApplyChangesOperation.cs (1)

117.Concat(changedProject.GetChangedAnalyzerConfigDocuments()).ToImmutableArray();

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (2)

120.ToImmutableArray(); 210var allDocChanges = group.ToImmutableArray();

CodeFixes\FixAllOccurrences\FixAllContextHelper.cs (1)

69.ToImmutableArray();

Diagnostics\DiagnosticAnalysisResultBuilder.cs (1)

193: map.ToImmutableDictionary(kv => kv.Key, kv => kv.Value.ToImmutableArray());

FindSymbols\Declarations\DeclarationFinder.cs (1)

61var symbolsWithName = symbols.ToImmutableArray();

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

29.ToImmutableArray<ISymbol>();

FindSymbols\SymbolFinder_Declarations_CustomQueries.cs (1)

108.ToImmutableArray();

PatternMatching\AllLowerCamelCaseMatcher.cs (1)

59? new NormalizedTextSpanCollection(result.Value.MatchedSpansInReverse).ToImmutableArray()

PatternMatching\PatternMatcher.cs (1)

547? new NormalizedTextSpanCollection(matchSpans.ToImmutableAndClear()).ToImmutableArray()

Remote\RemoteUtilities.cs (1)

37builder.Add((docId, textChanges.ToImmutableArray()));

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

730var possibleNameConflicts = possibleNameConflictsList.ToImmutableArray();

Rename\ConflictEngine\MutableConflictResolution.cs (3)

Rename\SymbolicRenameLocations.cs (2)

146var implicitLocations = referenceSymbols.SelectMany(refSym => refSym.Locations).Where(loc => loc.IsImplicit).ToImmutableArray(); 147var referencedSymbols = referenceSymbols.Select(r => r.Definition).Where(r => !r.Equals(symbol)).ToImmutableArray();

Shared\Extensions\IFindReferencesResultExtensions.cs (1)

106let aliasLocations = r.Locations.Where(loc => SymbolEquivalenceComparer.Instance.Equals(loc.Alias, aliasSymbol)).ToImmutableArray()

Shared\Extensions\ISymbolExtensions.cs (1)

425var typeParameterRefs = document.Descendants(DocumentationCommentXmlNames.TypeParameterReferenceElementName).ToImmutableArray();

src\Compilers\Core\Portable\DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (1)

395return _resolvedToOriginalPathMap.Select(x => (x.Value, x.Key)).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

245var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\AddImports\AbstractAddImportsService.cs (1)

168var contextSpine = applicableContainer.GetAncestorsOrThis<SyntaxNode>().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.cs (2)

86.ToImmutableArray(); 98.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

156.ToImmutableArray();

Workspace\Solution\Document.cs (1)

483var textChanges = text.GetTextChanges(oldText).ToImmutableArray();

Workspace\Solution\Solution.cs (1)

805var collection = analyzerReferences.ToImmutableArray();

Workspace\Solution\SolutionCompilationState.cs (3)

762var addedReferences = stateChange.NewProjectState.AnalyzerReferences.Except<AnalyzerReference>(stateChange.OldProjectState.AnalyzerReferences, ReferenceEqualityComparer.Instance).ToImmutableArray(); 763var removedReferences = stateChange.OldProjectState.AnalyzerReferences.Except<AnalyzerReference>(stateChange.NewProjectState.AnalyzerReferences, ReferenceEqualityComparer.Instance).ToImmutableArray(); 1352.ToImmutableArray();

Workspace\Solution\SolutionState.cs (6)

762var oldReferences = oldProject.ProjectReferences.ToImmutableArray(); 778var oldReferences = oldProject.ProjectReferences.ToImmutableArray(); 871var oldReferences = oldProject.MetadataReferences.ToImmutableArray(); 884var oldReferences = oldProject.MetadataReferences.ToImmutableArray(); 1235var oldReferences = AnalyzerReferences.ToImmutableArray(); 1242var oldReferences = AnalyzerReferences.ToImmutableArray();

Workspace\Workspace.cs (2)

1600var projectChangesList = solutionChanges.GetProjectChanges().ToImmutableArray(); 1777var changedDocumentIds = projectChanges.GetChangedDocuments(onlyGetDocumentsWithTextChanges: true, IgnoreUnchangeableDocumentsWhenApplyingChanges).ToImmutableArray();

Workspace\Host\Mef\MefV1HostServices.cs (2)

86return _exportProvider.GetExports<TExtension, TMetadata>().ToImmutableArray(); 102_exportProvider.GetExports<TExtension>().ToImmutableArray());

MSBuild\ProjectFile\ProjectFile.cs (5)

165.ToImmutableArray(); 169.ToImmutableArray(); 173.ToImmutableArray(); 180var fileGlobs = _loadedProject?.GetAllGlobs().Select(GetFileGlobs).ToImmutableArray() ?? []; 227.ToImmutableArray();

NewlyCreatedProjectsFromDotNetNew.cs (1)

225.ToImmutableArray();

Workspaces\TestWorkspace_XmlConsumption.cs (2)

287.Split(',').Select(v => KeyValuePair.Create(v.Split('=').ElementAt(0), (object)v.Split('=').ElementAt(1))).ToImmutableArray()); 734var aliases = aliasElement != null ? aliasElement.Split(',').Select(s => s.Trim()).ToImmutableArray() : default;

Workspaces\TestWorkspace`1.cs (1)

664var aliases = projectReference.Attributes(AliasAttributeName).Select(a => a.Value).ToImmutableArray();

SolutionTests\SolutionTests.cs (1)

4619return solution.GetProject(pid).GetCompilationAsync().Result.SyntaxTrees.ToImmutableArray();

src\Configuration.cs (2)

207return new BatchSignInput(_filesToSign.ToImmutableArray(), _zipDataMap.ToImmutableDictionary(), _filesToCopy.ToImmutableArray());

src\ContentUtil.cs (2)

40public static readonly ImmutableArray<byte> EmptyFileContentHash = GetContentHash(new MemoryStream()).ToImmutableArray(); 59return bytes.ToImmutableArray<byte>();

FakeBuildEngine.cs (1)

58var filesToSign = itemGroupNode.Descendants("FilesToSign").ToImmutableArray();

Signing.cs (1)

168if (!TryParseKey(File.ReadAllBytes(keyFile).ToImmutableArray(), out ImmutableArray<byte> snkPublicKey, out RSAParameters? privateKey) ||

Verification.cs (1)

113publicKeyBlob = Constants.ECMAKey.ToImmutableArray();

EquivalenceAssertsTests.cs (22)

HttpExceptionSummaryProvider.cs (1)

67_descriptions = descriptions.ToImmutableArray();

Parser.cs (2)

18.Select(type => new OptionsContextType(type.Key, type.Value.ToImmutableArray(), GetContextProperties(type.Key))) 88.ToImmutableArray();

EmitterTests.cs (4)

30.ToImmutableArray(); 53.ToImmutableArray(); 81.ToImmutableArray(); 109.ToImmutableArray();

LogParserUtilitiesTests.cs (1)

91.Returns(Array.Empty<AttributeData>().ToImmutableArray());

ParserUtilitiesTests.cs (3)

51.Returns(new[] { syntaxReferenceMock.Object, anotherSyntaxReferenceMock.Object }.ToImmutableArray()); 72.Returns(new[] { syntaxReferenceMock.Object }.ToImmutableArray()); 108.Returns(new[] { locationMock, Mock.Of<Location>() }.ToImmutableArray());

SymbolLoaderTests.cs (1)

30Array.Empty<MetadataReference>().ToImmutableArray(),

ComMethodContext.cs (1)

211var imm = methods.ToImmutableArray();

ComMethodInfo.cs (1)

97new ComMethodInfo(null!, method.Name, method.GetAttributes().Select(AttributeInfo.From).ToImmutableArray().ToSequenceEqual(), false),

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

42return (await Task.WhenAll(sortedProjects.Select(context.GetAllDiagnosticsAsync)).ConfigureAwait(false)).SelectMany(diag => diag).ToImmutableArray();

VtableIndexStubGenerator.cs (1)

320new SequenceEqualImmutableArray<DiagnosticInfo>(generatorDiagnostics.Diagnostics.ToImmutableArray()),

JSExportGenerator.cs (1)

214new SequenceEqualImmutableArray<DiagnosticInfo>(generatorDiagnostics.Diagnostics.ToImmutableArray()));

JSImportGenerator.cs (1)

196new SequenceEqualImmutableArray<DiagnosticInfo>(generatorDiagnostics.Diagnostics.ToImmutableArray()));

LibraryImportGenerator.cs (2)

318new SequenceEqualImmutableArray<AttributeSyntax>(additionalAttributes.ToImmutableArray(), SyntaxEquivalentComparer.Instance), 322new SequenceEqualImmutableArray<DiagnosticInfo>(generatorDiagnostics.Diagnostics.ToImmutableArray())

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

42return (await Task.WhenAll(sortedProjects.Select(context.GetAllDiagnosticsAsync)).ConfigureAwait(false)).SelectMany(diag => diag).ToImmutableArray();

DownlevelLibraryImportGenerator.cs (2)

224new SequenceEqualImmutableArray<AttributeSyntax>(additionalAttributes.ToImmutableArray(), SyntaxEquivalentComparer.Instance), 227new SequenceEqualImmutableArray<DiagnosticInfo>(generatorDiagnostics.Diagnostics.ToImmutableArray())

BoundGenerators.cs (2)

153.ToImmutableArray(), 169.Select(static info => GetInfoIndex(info)).ToImmutableArray();

GeneratedStatements.cs (1)

35Pin = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.Pin }).Cast<FixedStatementSyntax>().ToImmutableArray(),

MarshallerShape.cs (1)

618.ToImmutableArray();

MarshallingAttributeInfo.cs (1)

129return field ??= GetElementDependencies().ToImmutableArray();

MethodSignatureDiagnosticLocations.cs (1)

48: this(syntax.Identifier.Text, syntax.ParameterList.Parameters.Select(p => p.Identifier.GetLocation()).ToImmutableArray(), syntax.Identifier.GetLocation())

SequenceEqualImmutableArray.cs (2)

51return new(source.ToImmutableArray(), comparer); 55return new(source.ToImmutableArray());

ValueEqualityImmutableDictionary.cs (1)

39foreach (var kvp in Map.ToImmutableArray().Sort())

EquatableArray.cs (1)

20 public EquatableArray(T[] array) : this(array.ToImmutableArray())

DataDebuggerPreview.cs (2)

61RowView = rows.ToImmutableArray(); 62ColumnView = Enumerable.Range(0, n).Select(c => new ColumnInfo(data.Schema[c], columns[c].ToArray())).ToImmutableArray();

Evaluators\Metrics\ConfusionMatrix.cs (2)

81PerClassPrecision = precision.ToImmutableArray(); 82PerClassRecall = recall.ToImmutableArray();

Evaluators\Metrics\MulticlassClassificationMetrics.cs (3)

128TopKAccuracyForAllK = RowCursorUtils.Fetch<VBuffer<double>>(host, overallResult, MulticlassClassificationEvaluator.AllTopKAccuracy).DenseValues().ToImmutableArray(); 131PerClassLogLoss = perClassLogLoss.DenseValues().ToImmutableArray(); 144PerClassLogLoss = perClassLogLoss.ToImmutableArray();

Evaluators\Metrics\RankingMetrics.cs (4)

63DiscountedCumulativeGains = Fetch(RankingEvaluator.Dcg).DenseValues().ToImmutableArray(); 64NormalizedDiscountedCumulativeGains = Fetch(RankingEvaluator.Ndcg).DenseValues().ToImmutableArray(); 69DiscountedCumulativeGains = dcg.ToImmutableArray(); 70NormalizedDiscountedCumulativeGains = ndcg.ToImmutableArray();

Prediction\Calibrator.cs (6)

1915return new IsotonicCalibrator(Host, mins.ToImmutableArray(), maxes.ToImmutableArray(), values.ToImmutableArray()); 2030Mins = mins.ToImmutableArray(); 2031Maxes = maxes.ToImmutableArray(); 2032Values = values.ToImmutableArray();

Transforms\NormalizeColumnDbl.cs (1)

1377=> new NormalizingTransformer.BinNormalizerModelParameters<ImmutableArray<TFloat>>(_binUpperBounds.Select(b => ImmutableArray.Create(b)).ToImmutableArray(),

Transforms\NormalizeColumnSng.cs (1)

1540_binUpperBounds.Select(b => ImmutableArray.Create(b)).ToImmutableArray(),

VectorType.cs (1)

66Dimensions = dimensions.ToImmutableArray();

Standard\MulticlassClassification\OneVersusAllTrainer.cs (1)

273internal ImmutableArray<object> SubModelParameters => _impl.Predictors.Cast<object>().ToImmutableArray();

Transformers\NormalizerTests.cs (3)

257var transformers = transformer.ToImmutableArray(); 930var transformedDataArray = ML.Data.CreateEnumerable<DataPointOne>(noCdfData, false).ToImmutableArray(); 974var transformedDataArray = ML.Data.CreateEnumerable<DataPointVec>(noCdfData, false).ToImmutableArray();

PermutationFeatureImportance.cs (3)

132return metricsDelta.ToImmutableArray(); 164return metricsDelta.ToImmutableArray(); 248return metricsDelta.ToImmutableArray();

Text\LdaTransform.cs (1)

1093_columns = columns.ToImmutableArray();

Text\NgramHashingTransformer.cs (3)

183_columns = columns.ToImmutableArray(); 195_columns = columns.ToImmutableArray(); 327_columns = columns.ToImmutableArray();

Text\NgramTransform.cs (2)

217_transformInfos = transformInfos.ToImmutableArray(); 405_transformInfos = transformInfos.ToImmutableArray();

CallHierarchy\CallHierarchyProvider.cs (1)

138return finders.ToImmutableArray();

DocumentOutline\DocumentOutlineViewModel_Utilities.cs (1)

106.ToImmutableArray();

InheritanceMargin\InheritanceGlyphManager.cs (3)

117var remainingGlyphData = _glyphDataTree.Except(glyphDataToRemove).ToImmutableArray(); 136var allGlyphData = _glyphDataTree.ToImmutableArray(); 167var index = lines.ToImmutableArray().BinarySearch(span.Start, CompareWithLineStartAndEnd);

InheritanceMargin\InheritanceMarginTaggerProvider.cs (1)

116var membersOnTheLineArray = membersOnTheLine.ToImmutableArray();

MoveStaticMembers\VisualStudioMoveStaticMembersOptionsService.cs (1)

109var existingTypes = selectedType.ContainingNamespace.GetAllTypes(cancellationTokenSource.Token).ToImmutableArray();

ProjectSystem\BrokeredService\WorkspaceProject.cs (1)

47_project.AddAdditionalFile(additionalFile.FilePath, folderNames: additionalFile.FolderNames.ToImmutableArray());

ProjectSystem\VisualStudioWorkspaceImpl.cs (1)

637var distinctTextChanges = changesForFile.Value.Select(change => change.TextChange).Distinct().ToImmutableArray();

Snippets\SnippetExpansionClient.cs (1)

548var methodSymbols = symbols.OfType<IMethodSymbol>().ToImmutableArray();

SyncNamespaces\SyncNamespacesCommandHandler.cs (1)

108.ToImmutableArray();

TaskList\ExternalErrorDiagnosticUpdateSource.cs (1)

180var convertedDiagnostics = group.Select(d => CreateDiagnostic(projectId, projectHierarchyGuid, d, state.Solution)).ToImmutableArray();

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

39.ToImmutableArray();

UnusedReferences\RemoveUnusedReferencesCommandHandler.cs (2)

143.ToImmutableArray(); 200.ToImmutableArray();

Venus\ContainedDocument.DocumentServiceProvider.cs (1)

77var textChanges = (await newDocument.GetTextChangesAsync(oldDocument, cancellationToken).ConfigureAwait(false)).ToImmutableArray();

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

31AddRange(spacingOptions.ToImmutableArray()); 33AddRange(newLineOptions.ToImmutableArray()); 35AddRange(indentationOptions.ToImmutableArray()); 37AddRange(wrappingOptions.ToImmutableArray());

Client\RemoteLanguageServiceWorkspace.cs (1)

169var localPathsOfRemoteRoots = roots.Select(root => session.ConvertSharedUriToLocalPath(root)).ToImmutableArray();

Diagnostics\ExternalDiagnosticUpdateSourceTests.vb (5)

183Assert.Throws(Of InvalidOperationException)(Sub() source.AddNewErrors(project.Id, s_projectGuid, {diagnostic}.ToImmutableArray())) 210source.AddNewErrors(project.Id, s_projectGuid, {diagnostic}.ToImmutableArray()) 211source.AddNewErrors(project.Id, s_projectGuid, {diagnostic}.ToImmutableArray()) 228Dim analyzerReference = New AnalyzerImageReference(New DiagnosticAnalyzer() {compiler, analyzer}.ToImmutableArray()) 257source.AddNewErrors(project.Id, s_projectGuid, {diagnostic}.ToImmutableArray())

Venus\DocumentService_IntegrationTests.vb (1)

509Return AddSource(source, columns.ToImmutableArray())

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

67return builder.ToImmutableArray();

Implementation\LanguageServer\Handler\Completion\CompletionHandler.cs (1)

142var commitCharacters = xamlCommitCharacters.Characters.Select(c => new VSInternalCommitCharacter { Character = c.ToString(), Insert = !xamlCommitCharacters.NonInsertCharacters.Contains(c) }).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

245var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\AddImports\AbstractAddImportsService.cs (1)

168var contextSpine = applicableContainer.GetAncestorsOrThis<SyntaxNode>().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.cs (2)

86.ToImmutableArray(); 98.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

156.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (2)

53var leadingDirectives = statement.GetLeadingTrivia().Where(IsAnyCodeDirective).ToImmutableArray(); 54var closeBraceLeadingDirectives = block.CloseBraceToken.LeadingTrivia.Where(IsAnyCodeDirective).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Helpers\RemoveUnnecessaryImports\CSharpUnnecessaryImportsProvider.cs (1)

43return result.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\NamedTypeGenerator.cs (1)

81.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\SemanticModelExtensions.cs (4)

63arguments.Select(a => a.NameColon != null)).ToImmutableArray(); 66arguments.Select(a => semanticModel.GenerateNameForArgument(a, cancellationToken))).ToImmutableArray(); 86arguments.Select(a => a.NameEquals != null)).ToImmutableArray(); 89arguments.Select(a => semanticModel.GenerateNameForArgument(a, cancellationToken))).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Helpers\RemoveUnnecessaryImports\VisualBasicUnnecessaryImportsProvider.vb (1)

68Return unnecessaryImports.ToImmutableArray()

OptionPages\PerformanceLoggersPage.cs (2)

57var loggerTypeNames = GetLoggerTypes(globalOptions).ToImmutableArray(); 70var functionIds = Enum.GetValues(typeof(FunctionId)).Cast<FunctionId>().Where(isEnabled).ToImmutableArray();

Services\ServiceHubServicesTests.cs (3)

488var localGeneratedDocs = (await localProject.GetSourceGeneratedDocumentsAsync()).ToImmutableArray(); 489var remoteGeneratedDocs = (await remoteProject.GetSourceGeneratedDocumentsAsync()).ToImmutableArray(); 1508var documentNames = changedDocuments.ToImmutableArray();

Services\VisualStudioDiagnosticAnalyzerExecutorTests.cs (1)

207var analyzers = analyzerReference.GetAnalyzers(project.Language).Where(a => a.GetType() == analyzerType).ToImmutableArray();

AssemblyScheduler.cs (7)

110kvp => kvp.Value.Select(WithTypeExecutionTime).ToImmutableArray()); 117var tests = typeInfo.Tests.Select(WithTestExecutionTime).ToImmutableArray(); 205return workItems.ToImmutableArray(); 224.ToImmutableArray(); 227.ToImmutableArray(); 264.Select(group => new TypeInfo(GetName(group.Key), group.Key, group.Select(test => new TestMethodInfo(GetName(test), test, TimeSpan.Zero)).ToImmutableArray())) 265.ToImmutableArray();

ProcessTestExecutor.cs (1)

60var filters = workItem.Filters.Values.SelectMany(filter => filter).Where(filter => !string.IsNullOrEmpty(filter.FullyQualifiedName)).ToImmutableArray();

Program.cs (1)

351return list.ToImmutableArray();

TestRunner.cs (2)

69return workItems.ToImmutableArray(); 161return new RunAllResult((failures == 0), completed.ToImmutableArray(), processResults.ToImmutable());

GenerateFilteredReferenceAssembliesTask.cs (4)

118Rewrite(peImageBuffer, patterns.ToImmutableArray()); 391types.OrderBy(t => t.MetadataToken).ToImmutableArray(), 398methods.OrderBy(t => t.MetadataToken).ToImmutableArray(), 405fields.OrderBy(t => t.MetadataToken).ToImmutableArray(),

Helpers\RoslynExtensions.cs (1)

70.ToImmutableArray();

System\Windows\Forms\SourceGenerators\EnumValidationInfo.cs (1)

12var values = GetElementValues(enumType).OrderBy(e => e).Distinct().ToImmutableArray();

Infra\ScreenRecordService.cs (1)

457return (signature, ihdr, idat.ToImmutableArray(), iend);

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

IdentifiersShouldBeSpelledCorrectly.cs (1)

267.ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (1)

336select ComputeSynchronously(child, context)).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\Options\MSBuildItemOptionNames.cs (1)

53return ProduceTrimmedArray(itemOptionValue).ToImmutableArray();

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (1)

39.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\SectionMatcher_TryParseSection.cs (1)

63matcher = new SectionMatcher(new Regex(pattern), headerText, numberRangePairs.ToImmutableArray());

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AnonymousTypeSymbolKey.cs (2)

21var properties = symbol.GetMembers().OfType<IPropertySymbol>().ToImmutableArray(); 38var contextualProperties = contextualSymbol?.GetMembers().OfType<IPropertySymbol>().ToImmutableArray() ?? [];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

605foreach (var match in matches.ToImmutableArray())

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

245var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\AddImports\AbstractAddImportsService.cs (1)

168var contextSpine = applicableContainer.GetAncestorsOrThis<SyntaxNode>().ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.cs (2)

86.ToImmutableArray(); 98.ToImmutableArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

156.ToImmutableArray();