Select

Model\ResourceSourceViewModel.cs (2)

68return new CommandLineInfo(Arguments: launchArguments.Select(arg => new LaunchArgument(arg, true)).ToList(), ArgumentsString: argumentsString, TooltipString: argumentsString); 73var arguments = executableArguments.IsDefaultOrEmpty ? [] : executableArguments.Select(arg => new LaunchArgument(arg, true)).ToList();

ApplicationModel\ResourceExtensions.cs (1)

685return replicaAnnotation.Instances.Select(i => i.Name).ToArray();

ApplicationModel\ResourceNotificationService.cs (4)

589string.Join(" ", newState.Urls.Select(u => $"{u.Name} = {u.Url}")), 591string.Join(" ", newState.Properties.Select(p => $"{p.Name} = {Stringify(p.Value)}")), 592string.Join(" ", newState.HealthReports.Select(p => $"{p.Name} = {Stringify(p.Status)}")), 593string.Join(" ", newState.Commands.Select(c => $"{c.Name} ({c.DisplayName}) = {Stringify(c.State)}")));

AppHostAnalyzer.cs (1)

82.Select(ps => (Symbol: ps, ModelTypes: GetModelNameAttributes(ps)))

WithUrlsTests.cs (1)

439Urls = [.. s.Urls.Select(u => u with { IsInactive = false })]

ConfigSchemaGenerator.cs (2)

82(exclusionPaths ??= new()).AddRange(exclusionPathsArg.Values.Select(v => $"{path}:{(string)v.Value}")); 93(logCategories ??= new()).AddRange(args[0].Values.Select(v => (string)v.Value));

DynamicallyAccessedMembersCodeFixProvider.cs (1)

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

RequiresAssemblyFilesCodeFixProvider.cs (1)

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

RequiresDynamicCodeCodeFixProvider.cs (1)

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

RequiresUnreferencedCodeCodeFixProvider.cs (1)

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

TrimAnalysis\TrimAnalysisVisitor.cs (1)

110 var elements = operation.Initializer?.ElementValues.Select (val => Visit (val, state)).ToArray () ?? System.Array.Empty<MultiValue> ();

ApiLifecycle\AssemblyAnalysis.cs (1)

141var baseTypes = new HashSet<string>(type.AllInterfaces.Select(x => x.ToDisplayString(_shortSymbolNameFormat)));

CodeFixRunner.cs (1)

56diagnostics.Select(d => CSharpDiagnosticFormatter.Instance.Format(d, CultureInfo.InvariantCulture)));

RouteEmbeddedLanguage\Infrastructure\EmbeddedLanguageCommentDetector.cs (1)

28var namePortion = string.Join("|", identifiers.Select(n => $"({Regex.Escape(n)})"));

RouteEmbeddedLanguage\RoutePatternAnalyzer.cs (1)

71var routeParameterNames = new HashSet<string>(routeUsage.RoutePattern.RouteParameters.Select(p => p.Name), StringComparer.OrdinalIgnoreCase);

src\Shared\RoslynUtils\SymbolExtensions.cs (1)

223var parameterTypes = constructor.Parameters.Select(parameter => $"typeof({parameter.Type.ToDisplayString()})");

RouteEmbeddedLanguage\RoutePatternParserTests.cs (2)

187string.Join(Environment.NewLine, tree.Diagnostics.Select(d => d.Message))); 284tree.Diagnostics.Select(d =>

src\Shared\RoslynUtils\SymbolExtensions.cs (1)

223var parameterTypes = constructor.Parameters.Select(parameter => $"typeof({parameter.Type.ToDisplayString()})");

Evaluation\LazyItemEvaluator.IncludeOperation.cs (1)

166DecorateItemsWithMetadata(items.Select(i => new ItemBatchingContext(i)), _metadata);

CommandLine\CommonCompiler.CompilerEmitStreamProvider.cs (1)

127string.Join(", ", lockedBy.Select(info => $"'{info.applicationName}' ({info.processId})")));

CommandLine\CommonCompiler.cs (3)

433var embeddedFileOrderedSet = new OrderedSet<string>(Arguments.EmbeddedFiles.Select(e => e.Path)); 500var set = new HashSet<string>(arguments.EmbeddedFiles.Select(f => f.Path)); 501set.IntersectWith(arguments.SourceFiles.Select(f => f.Path));

CommandLine\ReportAnalyzerUtil.cs (2)

108DiagnosticSuppressor suppressor => suppressor.SupportedSuppressions.Select(s => s.Id), 109_ => analyzer.SupportedDiagnostics.Select(d => d.Id),

DiagnosticAnalyzer\AnalyzerDriver.GroupedAnalyzerActions.cs (2)

81var inputAnalyzers = groupedAnalyzerActions.GroupedActionsByAnalyzer.Select(a => a.analyzer); 82var myAnalyzers = GroupedActionsByAnalyzer.Select(a => a.analyzer);

SourceGeneration\GeneratorDriver.cs (3)

76trees.AddRange(generatorState.PostInitTrees.Select(t => t.Tree)); 77trees.AddRange(generatorState.GeneratedTrees.Select(t => t.Tree)); 296constantSourcesBuilder.AddRange(generatorState.PostInitTrees.Select(t => t.Tree));

SourceGeneration\RunResults.cs (1)

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

MetaAnalyzers\DiagnosticAnalyzerCorrectnessAnalyzer.SyntaxNodeWithinAnalyzerTypeCompilationAnalyzer.cs (1)

26foreach (SyntaxNode syntax in namedType.DeclaringSyntaxReferences.Select(s => s.GetSyntax(cancellationToken)))

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (1)

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

MetaAnalyzers\Fixers\CompareSymbolsCorrectlyFix.cs (1)

219var arguments = invocationOperation.Arguments.Select(argument => argument.Syntax);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (1)

490.Select<IOperation, TaintedDataAbstractValue>(this.GetCachedAbstractValue)

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

69arguments.Select(o => 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\AnalysisEntityFactory.cs (1)

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

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

70using var pendingBlocksNeedingAtLeastOnePass = PooledSortedSet<int>.GetInstance(cfg.Blocks.Select(b => b.Ordinal));

src\Analyzers\Core\Analyzers\AbstractBuiltInUnnecessaryCodeStyleDiagnosticAnalyzer.cs (2)

106AddDescriptorsToFadingOptionMapping(supportedDiagnosticsWithOptions.Select(static item => item.Descriptor), fadingOption); 115AddDescriptorsToFadingOptionMapping(supportedDiagnosticsWithOptions.Select(static item => item.Descriptor), fadingOption);

src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

661foreach (var tree in namedTypeSymbol.Locations.Select(l => l.SourceTree).Distinct().WhereNotNull())

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

187if (!namedType.DeclaringSyntaxReferences.Select(d => d.SyntaxTree).Distinct().Any(tree =>

src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerDiagnosticAnalyzer.cs (1)

175nodes = nodes.AddRange(matches.Select(static m => m.Node));

src\Analyzers\Core\Analyzers\UseObjectInitializer\AbstractUseObjectInitializerDiagnosticAnalyzer.cs (1)

119var nodes = ImmutableArray.Create<SyntaxNode>(containingStatement).AddRange(matches.Select(m => m.Statement));

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

44.Select(section => (matchKind: section.GetMatchKind(language), section))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.cs (1)

432=> _relativeIndentationTree.Algorithms.GetIntervalsThatIntersectWith(this.TreeData.StartPosition, this.TreeData.EndPosition, new FormattingContextIntervalIntrospector()).Select(i => i.Operation);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (3)

307return string.Join(", ", symbols.Select(symbol => symbol.ToEditorConfigString())); 405return string.Join(", ", accessibilities.Select(accessibility => accessibility.ToEditorConfigString(languageName))); 464return string.Join(", ", modifiers.Select(modifier => modifier.ToEditorConfigString(languageName)));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (3)

350new XElement("SymbolSpecifications", SymbolSpecifications.Select(s => s.CreateXElement())), 351new XElement("NamingStyles", NamingStyles.Select(n => n.CreateXElement())), 352new XElement("NamingRules", SerializableNamingRules.Select(n => n.CreateXElement())));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

98selectedMembers.AddRange(GetDeclaratorsAndIdentifiers(member).Select(pair => pair.declarator));

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

602var declarationSyntax = symbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).FirstOrDefault();

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

15=> typeParameter.ConstraintTypes.Select(GetNamedTypeSymbol).WhereNotNull().FirstOrDefault();

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

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();

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

112symbols.AddRange(interfaceType.AllInterfaces.Select(i => i.OriginalDefinition));

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

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this));

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

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();

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

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();

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

365var parameters = methodToUpdate.Parameters.Select(p => p.ToDisplayString(SimpleFormat)); 440methodParameterNames.AddRange(method.Parameters.Select(p => p.Name));

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

232var uniqueName = NameGenerator.EnsureUniqueness(argumentNameSuggestion, method.Parameters.Select(p => p.Name));

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

161[.. delegatedConstructor.Parameters.Select(p => p.Name)], 167if (delegatedConstructor.Parameters.Select(p => p.Name).Intersect(remainingParameterNames.Select(n => n.BestNameForParameter)).Any()) 221constructor.Parameters.Select(p => p.Type).SequenceEqual(ParameterTypes)) 280var allTypes = _arguments.Select(a => _service.GetArgumentType(_document.SemanticModel, a, cancellationToken));

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.cs (1)

55string.Join(", ", constructor.Parameters.Select(p => p.Name))),

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeAction.cs (1)

38_constructors.Select(CreateConstructorDefinition),

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.SignatureInfo.cs (2)

127.Select(p => p.BestNameForParameter) 203var types = await SpecializedTasks.WhenAll(DetermineParameterTypes(cancellationToken).Select(t => FixTypeAsync(t, cancellationToken))).ConfigureAwait(false);

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

846var spansToFormat = originalDeclStatementsToMoveOrRemove.Select(s => s.Span);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamedTypeSymbol.cs (1)

87return this.GetMembers().Select(m => m.Name).ToList();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\DocumentExtensions.cs (1)

192var diagnostics = string.Join(", ", errors.Select(d => d.ToString()));

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

45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (1)

159IEnumerable<(TType instance, (TNode semanticNode, IEnumerable<TNode> additionalNodes) nodes)> originalNodePairs = originalNodes.Select(n => (n, selector(n)));

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

85.Select(t => t.InferredType) 97.Select(info => info.InferredType)

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

142=> [.. services.Select(s => (s.Metadata.ServiceType, s.Metadata.Layer))];

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

216=> [.. services.Select(s => (s.Metadata.ServiceType, s.Metadata.Layer))];

Binder\Binder_InterpolatedString.cs (2)

669Debug.Assert(appendCallsArray.Select(a => a.Length).SequenceEqual(partsArray.Select(a => a.Length)));

Binder\Binder_Statements.cs (1)

3894containerNode = containingType.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).OfType<TypeDeclarationSyntax>().First();

Binder\DecisionDagBuilder.cs (3)

1716var bindings = cd.Bindings.Select(bpb => $"{(bpb.VariableAccess is BoundLocal l ? l.LocalSymbol.Name : "<var>")}={tempName(bpb.TempContainingValue)}"); 2454return $"AND({string.Join(", ", RemainingTests.Select(t => t.Dump(dump)))})"; 2508return $"OR({string.Join(", ", RemainingTests.Select(t => t.Dump(dump)))})";

Binder\Imports.cs (3)

54Usings.Select(u => u.NamespaceOrType.ToString())).Concat( 55ExternAliases.Select(ea => $"extern alias {ea.Alias.Name}"))); 205replacedExternAliases.AddAll(externs2.Select(e => e.Alias.Name));

BoundTree\LengthBasedStringSwitchData.cs (1)

266builder.AppendLine($"Buckets: {string.Join(", ", StringBasedJumpTables.Select(t => t.StringCaseLabels.Length))}");

Compilation\CSharpCompilation.cs (1)

1589uniqueUsings.AddAll(usingsFromoptions.UsingNamespacesOrTypes.Select(static unt => unt.NamespaceOrType));

Emitter\Model\PEModuleBuilder.cs (1)

2063.Select(type => type.GetCciAdapter())

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.ValueDispatchNode.cs (1)

45public override string ToString() => "[" + string.Join(",", Cases.Select(c => c.value)) + "]";

Symbols\NativeIntegerTypeSymbol.cs (1)

53public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name);

Symbols\Source\SourceMemberContainerSymbol.cs (1)

1278return (IsTupleType || IsRecord || IsRecordStruct || this.declaration.ContainsExtensionDeclarations) ? GetMembers().Select(m => m.Name) : this.declaration.MemberNames;

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

326uniqueUsings.AddAll(namespacesOrTypes.Select(n => n.NamespaceOrType)); 868uniqueUsings.AddAll(globalUsingNamespacesOrTypes.Select(n => n.NamespaceOrType));

Symbols\SubstitutedNamedTypeSymbol.cs (2)

197return new List<string>(GetTypeMembersUnordered().Select(s => s.Name).Distinct()); 202return GetMembers().Select(s => s.Name).Distinct();

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (1)

131public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name);

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (1)

808public override IEnumerable<string> MemberNames => GetMembers().Select(m => m.Name);

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (1)

69public override IEnumerable<string> MemberNames => Constructors.Select(m => m.Name);

Symbols\Synthesized\SynthesizedHotReloadExceptionSymbol.cs (1)

65=> _members.Select(static m => m.Name);

Symbols\TypedConstantExtensions.cs (1)

27return "{" + string.Join(", ", constant.Values.Select(v => v.ToCSharpString())) + "}";

Utilities\ValueSetFactory.NumericValueSet.cs (1)

317return string.Join(",", this._intervals.Select(p => $"[{_tc.ToString(p.first)}..{_tc.ToString(p.last)}]"));

src\Analyzers\CSharp\Analyzers\QualifyMemberAccess\CSharpQualifyMemberAccessDiagnosticAnalyzer.cs (1)

57.Select(declaringSyntaxReferences => declaringSyntaxReferences.GetSyntax())

src\Analyzers\CSharp\Analyzers\RemoveUnusedMembers\CSharpRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

29.Select(r => r.GetSyntax(cancellationToken))

src\Analyzers\CSharp\Analyzers\UseDeconstruction\CSharpUseDeconstructionDiagnosticAnalyzer.cs (1)

208.Select(s => s.Name)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\CSharpCodeStyleOptions.cs (1)

181defaultValue: new CodeStyleOption2<string>(string.Join(",", s_preferredModifierOrderDefault.Select(SyntaxFacts.GetText)), NotificationOption2.Silent));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

95var enumDecl = namedTypeSymbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).OfType<EnumDeclarationSyntax>().FirstOrDefault();

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (3)

174.SequenceEqual(propertiesToAssign.Select(property => property.Type))) 183.Select(expression => 192ArgumentList([.. expressions.Select(Argument)])));

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\PositionalParameterInfo.cs (1)

48resultBuilder.AddRange(inheritedProperties.Select(property => new PositionalParameterInfo(

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\PassInCapturedVariablesAsArgumentsCodeFixProvider.cs (1)

77.Select(d => root.FindNode(d.Location.SourceSpan).AncestorsAndSelf().OfType<LocalFunctionStatementSyntax>().FirstOrDefault())

src\Analyzers\CSharp\CodeFixes\UseDeconstruction\CSharpUseDeconstructionCodeFixProvider.cs (1)

160[.. tupleType.TupleElements.Select(

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

50.Select(d => GetInvocationExpression(d, cancellationToken))

src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (1)

247: ParameterList([.. delegateMethod.Parameters.Select(parameter =>

src\Analyzers\CSharp\CodeFixes\UseSimpleUsingStatement\UseSimpleUsingStatementCodeFixProvider.cs (1)

110compilationUnit.Members.ReplaceRange((GlobalStatementSyntax)usingStatement.GetRequiredParent(), expandedUsingStatements.Select(GlobalStatement))),

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

105=> ArgumentList([.. arguments.Select(ArgumentGenerator.GenerateArgument)]);

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

43[.. typedConstant.Values.Select(v => GenerateExpression(v))]));

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

24[.. typeParameters.Select(t => GenerateTypeParameter(t, info))]);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs (1)

164var parameters = symbol.Signature.Parameters.Select(p => (p.Type, RefKindModifiers: CSharpSyntaxGeneratorInternal.GetParameterModifiers(p)))

src\Analyzers\CSharp\Tests\SimplifyInterpolation\SimplifyInterpolationTests.cs (1)

46diagnostics.Select(d => (d.Descriptor.Id, d.Severity)));

CommandLineTests.cs (29)

EventHookup\EventHookupSessionManager_EventHookupSession.cs (1)

209var reservedNames = semanticModel.LookupSymbols(plusEqualsToken.SpanStart).Select(m => m.Name);

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (14)

QuickInfo\DiagnosticAnalyzerQuickInfoSourceTests.cs (1)

186[.. info.RelatedSpans.Select(actualSpan => new Action<TextSpan>(expectedSpan => Assert.Equal(expectedSpan, actualSpan)))]);

QuickInfo\SemanticQuickInfoSourceTests.cs (1)

8547item.Sections.First(section => section.Kind == QuickInfoSectionKinds.DocumentationComments).TaggedParts.Select(p => p.Tag).ToArray(),

SymbolKey\SymbolKeyTestBase.cs (1)

128foreach (var node in symbol.DeclaringSyntaxReferences.Select(d => d.GetSyntax()))

CodeGen\CodeGenTupleTest.cs (2)

6041Assert.All(tuple8WithoutNames.TupleElements.Select(f => f.Locations.FirstOrDefault()), 13878AssertEx.Equal(baseLine, symbols.Select(s => s.ToTestDisplayString()));

Emit\CompilationEmitTests.cs (2)

660peReader.PEHeaders.SectionHeaders.Select(h => h.Name)); 2625AssertEx.Equal(expected, entries.Select(e => e.Type));

PDB\CSharpDeterministicBuildCompilationTests.cs (1)

74AssertEx.Equal(new[] { DebugDirectoryEntryType.CodeView, DebugDirectoryEntryType.PdbChecksum, DebugDirectoryEntryType.Reproducible, DebugDirectoryEntryType.EmbeddedPortablePdb }, entries.Select(e => e.Type));

PDB\PortablePdbTests.cs (2)

177AssertEx.Equal(new[] { DebugDirectoryEntryType.CodeView, DebugDirectoryEntryType.PdbChecksum, DebugDirectoryEntryType.EmbeddedPortablePdb }, entries.Select(e => e.Type)); 237AssertEx.Equal(new[] { DebugDirectoryEntryType.CodeView, DebugDirectoryEntryType.PdbChecksum, DebugDirectoryEntryType.Reproducible, DebugDirectoryEntryType.EmbeddedPortablePdb }, entries.Select(e => e.Type));

Attributes\AttributeTests.cs (1)

655Assert.Equal(new object[] { 1, 2, 3 }, attributeData.ConstructorArguments.Single().Values.Select(arg => arg.Value));

FlowAnalysis\FlowTests.cs (1)

5843var property = declarations.Select(d => model.GetDeclaredSymbol(d)).Where(p => p.ContainingSymbol.Name == "Program").Single();

FlowAnalysis\RegionAnalysisTests.cs (2)

1372string.Join(", ", new string[] { "f" }.Concat((results2.ReadOutside).Select(symbol => symbol.Name)).OrderBy(name => name))); 1376string.Join(", ", new string[] { "f" }.Concat((results2.WrittenOutside).Select(symbol => symbol.Name)).OrderBy(name => name)));

Semantics\ExtensionTests.cs (3)

2626AssertEx.SetEqual(["System.ObsoleteAttribute"], symbol.GetAttributes().Select(a => a.ToString())); 3419AssertEx.SetEqual(["MyAttribute"], parameterSymbol.GetAttributes().Select(a => a.ToString())); 3423AssertEx.SetEqual(["MyAttribute"], extensionSymbol.ExtensionParameter.GetAttributes().Select(a => a.ToString()));

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

318reservedNames: declaredSymbol.ContainingType.GetMembers().Select(m => m.Name));

Completion\CompletionProviders\AttributeNamedParameterCompletionProvider.cs (1)

202=> existingNamedParameters.Except(parameterList.Select(p => p.Name)).IsEmpty();

Completion\CompletionProviders\NamedParameterCompletionProvider.cs (1)

139return existingNamedParameters.Except(parameterList.Select(p => p.Name)).IsEmpty();

Completion\CompletionProviders\PartialMethodCompletionProvider.cs (1)

84var declarations = method.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).OfType<MethodDeclarationSyntax>();

ConvertIfToSwitch\CSharpConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (1)

35[.. sections.Select(section => AsSwitchExpressionArmSyntax(section, feature))]));

ConvertToExtension\ConvertToExtensionFixAllProvider.cs (1)

68.Select(span => root.FindNode(span) as ClassDeclarationSyntax)

EncapsulateField\CSharpEncapsulateFieldService.cs (1)

203c => c.DeclaringSyntaxReferences.Select(d => d.GetSyntax()).OfType<ConstructorDeclarationSyntax>());

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.CallSiteContainerRewriter.cs (1)

337_statementsOrMemberOrAccessorToInsert.Select(s => global ? SyntaxFactory.GlobalStatement((StatementSyntax)s) : (MemberDeclarationSyntax)s));

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (3)

880: TupleExpression([.. variableInfos.Select(v => Argument(v.Name.ToIdentifierName()))]), 943_ => ParenthesizedVariableDesignation([.. variableInfos.Select(v => SingleVariableDesignation(v.Name.ToIdentifierToken()))]), 970_ => TupleExpression([.. variableInfos.Select(v => Argument(CreateReturnExpression(v)))]),

SignatureHelp\AbstractOrdinaryMethodSignatureHelpProvider.cs (1)

43[.. method.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService))],

SignatureHelp\ConstructorInitializerSignatureHelpProvider.cs (1)

147[.. constructor.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService))]);

SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (1)

233[.. indexer.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService))]);

SignatureHelp\GenericNameSignatureHelpProvider.cs (2)

187[.. namedType.TypeParameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService))]); 200[.. method.TypeParameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService))]);

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider_NormalType.cs (1)

34[.. constructor.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService))]);

SignatureHelp\PrimaryConstructorBaseTypeSignatureHelpProvider.cs (1)

134[.. constructor.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService))]);

src\Analyzers\CSharp\Analyzers\QualifyMemberAccess\CSharpQualifyMemberAccessDiagnosticAnalyzer.cs (1)

57.Select(declaringSyntaxReferences => declaringSyntaxReferences.GetSyntax())

src\Analyzers\CSharp\Analyzers\RemoveUnusedMembers\CSharpRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

29.Select(r => r.GetSyntax(cancellationToken))

src\Analyzers\CSharp\Analyzers\UseDeconstruction\CSharpUseDeconstructionDiagnosticAnalyzer.cs (1)

208.Select(s => s.Name)

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (3)

174.SequenceEqual(propertiesToAssign.Select(property => property.Type))) 183.Select(expression => 192ArgumentList([.. expressions.Select(Argument)])));

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\PositionalParameterInfo.cs (1)

48resultBuilder.AddRange(inheritedProperties.Select(property => new PositionalParameterInfo(

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\PassInCapturedVariablesAsArgumentsCodeFixProvider.cs (1)

77.Select(d => root.FindNode(d.Location.SourceSpan).AncestorsAndSelf().OfType<LocalFunctionStatementSyntax>().FirstOrDefault())

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

50.Select(d => GetInvocationExpression(d, cancellationToken))

src\Analyzers\CSharp\CodeFixes\UseSimpleUsingStatement\UseSimpleUsingStatementCodeFixProvider.cs (1)

110compilationUnit.Members.ReplaceRange((GlobalStatementSyntax)usingStatement.GetRequiredParent(), expandedUsingStatements.Select(GlobalStatement))),

ExtractClass\ExtractClassTests.cs (1)

3142selections = selectedMembers.Select(m => (m, makeAbstract: false));

src\Analyzers\CSharp\Tests\SimplifyInterpolation\SimplifyInterpolationTests.cs (1)

46diagnostics.Select(d => (d.Descriptor.Id, d.Severity)));

CommandLineRunnerTests.cs (1)

692}, arguments.MetadataReferences.Select(r => r.Reference));

ScriptTests.cs (3)

403AssertEx.Equal(new[] { "a", "b", "a", "x", "X" }, state.Variables.Select(v => v.Name)); 404AssertEx.Equal(new object[] { '1', 2u, 3m, 5m, 20 }, state.Variables.Select(v => v.Value)); 405AssertEx.Equal(new Type[] { typeof(char), typeof(uint), typeof(decimal), typeof(decimal), typeof(int) }, state.Variables.Select(v => v.Type));

Semantics\NameOfTests.cs (1)

1084symbols.Select(s => s.GetPublicSymbol()),

SourceGeneration\GeneratorDriverFuzzTests.cs (1)

218string.Join("", pair.Right.Select(text => text.GetText()!.ToString()))));

SourceGeneration\GeneratorDriverTests.cs (3)

2172invokedMethods.Select(m => $"// {m}"))); 2383driver.GetRunResult().Results.Single().TrackedSteps["Select"].Select(r => r.Outputs.Single())); 2404driver.GetRunResult().Results.Single().TrackedSteps["Select"].Select(r => r.Outputs.Single()));

SourceGeneration\GeneratorDriverTests_Attributes_FullyQualifiedName.cs (1)

1294Assert.Equal(expectedGeneratedSources, driver.GetRunResult().Results.Single().GeneratedSources.Select(s => (s.HintName, s.SourceText.ToString())));

DocumentationComments\CrefTests.cs (1)

2018AssertEx.SetEqual(info.CandidateSymbols.Select(sym => sym.ContainingAssembly.Name), "Lib1", "Lib2");

SymbolDisplay\SymbolDisplayTests.cs (1)

3747AssertEx.Equal(expectedKinds, actualParts.Select(p => p.Kind), itemInspector: p => $" SymbolDisplayPartKind.{p}");

Symbols\ExtensionMethodTests.cs (1)

3784var symbols = model.LookupSymbols(member.Expression.EndPosition, type, includeReducedExtensionMethods: true).Select(s => s.Name).ToArray();

Symbols\Source\DeclaringSyntaxNodeTests.cs (2)

39foreach (var node in declaringReferences.Select(d => d.GetSyntax())) 102foreach (var node in declaringReferences.Select(d => d.GetSyntax()))

CompilationTestUtils.cs (2)

63AssertEx.SetEqual(symbols.Select(s => s.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)), descriptions); 350return symbols.Select(s => s.Name).Distinct().ToList();

CSharpTestBase.cs (3)

2256return attributes.Select(a => a.AttributeClass!.Name); 2261return attributes.Select(a => a.AttributeClass!.Name); 2266return attributes.Select(a => a.ToString()!);

Extensions.cs (2)

874return type.TypeArguments.Select(t => t.NullableAnnotation); 879return method.TypeArguments.Select(t => t.NullableAnnotation);

FunctionPointerUtilities.cs (2)

198AssertEx.Equal(expectedSymbolCandidates, semanticInfo.MemberGroup.Select(s => s.ToTestDisplayString(includeNonNullable: false))); 226AssertEx.Equal(expectedSymbolCandidates, semanticInfo.CandidateSymbols.Select(s => s.ToTestDisplayString(includeNonNullable: false)));

Rename\CSharpRenameRewriterLanguageService.cs (1)

843conflicts.AddRange(DeclarationConflictHelpers.GetMembersWithConflictingSignatures((IMethodSymbol)renamedSymbol, trimOptionalParameters: false).Select(t => reverseMappedLocations[t]));

Simplification\CSharpSimplificationService.Expander.cs (1)

746[.. typeArguments.Select(p => ParseTypeName(p.ToDisplayString(s_typeNameFormatWithGenerics)))]))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\CSharpCodeStyleOptions.cs (1)

181defaultValue: new CodeStyleOption2<string>(string.Join(",", s_preferredModifierOrderDefault.Select(SyntaxFacts.GetText)), NotificationOption2.Silent));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

95var enumDecl = namedTypeSymbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).OfType<EnumDeclarationSyntax>().FirstOrDefault();

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

105=> ArgumentList([.. arguments.Select(ArgumentGenerator.GenerateArgument)]);

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

43[.. typedConstant.Values.Select(v => GenerateExpression(v))]));

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

24[.. typeParameters.Select(t => GenerateTypeParameter(t, info))]);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs (1)

164var parameters = symbol.Signature.Parameters.Select(p => (p.Type, RefKindModifiers: CSharpSyntaxGeneratorInternal.GetParameterModifiers(p)))

CodeGeneration\SyntaxGeneratorTests.cs (13)

EditAndContinue\ActiveStatementTrackingService.cs (1)

205solution = solution.WithUpToDateSourceGeneratorDocuments(openDocumentIds.Select(static d => d.ProjectId));

InlineRename\AbstractEditorInlineRenameService.InlineRenameReplacementInfo.cs (1)

61.Select(s => new InlineRenameReplacement(InlineRenameReplacementKind.Complexified, s.oldSpan, s.newSpan));

InlineRename\UI\Adornment\RenameFlyoutViewModel.cs (1)

398var referenceCount = renameLocations.Select(loc => (loc.Document.FilePath, loc.TextSpan)).Distinct().Count();

Interactive\ResetInteractive.cs (1)

113var importReferencesCommand = referencePaths.Select(_createReference);

QuickInfo\AbstractSemanticQuickInfoSourceTests.cs (1)

67var actualText = string.Concat(taggedText.Select(tt => tt.Text));

CodeFixes\CodeFixServiceTests.cs (1)

1101Assert.Equal(analyzer.SupportedDiagnostics.Select(d => d.Id), lowPriorityAnalyzerData.SupportedDiagnosticIds);

InheritanceMargin\InheritanceMarginTests.cs (1)

131.Select(info => TestInheritanceTargetItem.Create(info, testWorkspace))

Snippets\RoslynLSPSnippetConvertTests.cs (1)

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

SuggestedActions\SuggestedActionSourceProviderTests.cs (1)

23AssertEx.SetEqual(attributes.Select(a => a.Priority), SuggestedActionsSourceProvider.Orderings);

PDB\MethodDebugInfo.cs (1)

92HoistedLocalScopeRecords.Select(record => new ILSpan((uint)record.StartOffset, (uint)(record.StartOffset + record.Length))));

FunctionResolverTestBase.cs (1)

30var actualSignatures = request.GetResolvedAddresses().Select(a => GetMethodSignature(a.Module, a.Token));

Symbols\ISymbolExtensions.cs (1)

602var declarationSyntax = symbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).FirstOrDefault();

Symbols\ITypeParameterSymbolExtensions.cs (1)

15=> typeParameter.ConstraintTypes.Select(GetNamedTypeSymbol).WhereNotNull().FirstOrDefault();

Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (1)

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();

Symbols\ITypeSymbolExtensions.cs (1)

112symbols.AddRange(interfaceType.AllInterfaces.Select(i => i.OriginalDefinition));

Symbols\ITypeSymbolExtensions.SubstituteTypesVisitor.cs (1)

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this));

Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (1)

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();

Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (1)

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();

Internal\NavigateTo\FSharpNavigateToSearchService.cs (1)

59Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1);

RazorMappingServiceWrapper.cs (1)

29var changesCount = mappedEdits.Select(e => e.IsDefault ? 0 : e.TextChanges.Length).Sum();

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (1)

90var parameters = _constructorCandidate.Constructor.Parameters.Select(p => p.ToDisplayString(SimpleFormat));

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (1)

120!parameterNamesForSelectedMembers.Except(constructorParams.Select(p => p.Name)).Any();

AddDebuggerDisplay\AbstractAddDebuggerDisplayCodeRefactoringProvider.cs (1)

110.Select(data => data.AttributeClass)

AddFileBanner\AbstractAddFileBannerCodeRefactoringProvider.cs (1)

100var bannerText = banner.Select(trivia => trivia.ToFullString()).Join(string.Empty);

AddPackage\InstallPackageParentCodeAction.cs (1)

52.. installedVersions.Select(v => CreateCodeAction(

ChangeSignature\AbstractChangeSignatureService.cs (1)

182[.. GetParameters(symbol).Select(p => new ExistingParameter(p))],

CodeFixes\Configuration\ConfigurationUpdater.cs (1)

140codeStyleOptionValues.Select(t => (t.optionName, t.currentOptionValue, t.isPerLanguage)),

CodeLens\CodeLensReferencesService.cs (2)

208.Select(location => GetDescriptorOfEnclosingSymbolAsync(solution, location, cancellationToken)) 266.Select(location => TryGetMethodDescriptorAsync(location, solution, cancellationToken))

Completion\CompletionDescription.cs (1)

68Interlocked.CompareExchange(ref _text, string.Concat(TaggedParts.Select(p => p.Text)), null);

Completion\CompletionService.cs (1)

290items.Select(item => helper.GetMatchResult(item, includeMatchSpans: false, CultureInfo.CurrentCulture)));

Completion\Providers\AbstractDocCommentCompletionProvider.cs (10)

145var items = s_nestedTagNames.Select(GetItem); 155items = items.Concat(GetKeywordNames().Select(CreateLangwordCompletionItem)); 163var names = GetParameters(symbol).Select(p => p.Name); 188.Select(parameter => CreateCompletionItem(parameter.Name)); 203return GetKeywordNames().Select(CreateCompletionItem); 207return s_listTypeValues.Select(CreateCompletionItem); 221items.AddRange(s_topLevelRepeatableTagNames.Select(GetItem)); 256=> s_listTagNames.Select(GetItem); 259=> s_listHeaderTagNames.Select(GetItem); 263var names = symbols.Select(p => p.Name).ToSet();

Completion\Providers\AbstractPartialTypeCompletionProvider.cs (1)

106.Select(reference => reference.GetSyntax())

Completion\Providers\AbstractSymbolCompletionProvider.cs (1)

68var declarationSyntax = symbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).SingleOrDefault();

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

94receiverTypeSymbol = errorTypeSymbol.CandidateSymbols.Select(GetSymbolType).FirstOrDefault(s => s != null);

Completion\Providers\SymbolCompletionItem.cs (3)

112return string.Join("|", symbols.Select(EncodeSymbol)); 227properties.Add(KeyValuePairUtil.Create("InvalidProjects", string.Join(";", supportedPlatforms.InvalidProjects.Select(id => id.Id)))); 228properties.Add(KeyValuePairUtil.Create("CandidateProjects", string.Join(";", supportedPlatforms.CandidateProjects.Select(id => id.Id))));

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (2)

235classSymbol.TypeParameters.Select(tp => g.IdentifierName(tp.Name))); 254properties.Select(p => p.Type)

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

272var knownCollectionInterfaces = s_KnownInterfaceNames.Select(

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (2)

44: CreateSwitchStatement(ifStatement, target, sections.Select(section => AsSwitchSectionSyntax(section, generator, feature))); 65: generator.SwitchSectionFromLabels(section.Labels.Select(label => AsSwitchLabelSyntax(label, feature)), statements);

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)

285tupleType.TupleElements.Select(p => p.Type) 414: (TNameSyntax)generator.GenericName(structNameToken, typeParameters.Select(tp => generator.IdentifierName(tp.Name)));

Copilot\ICopilotChangeAnalysisService.cs (1)

59Contract.ThrowIfTrue(new NormalizedTextSpanCollection(changes.Select(c => c.Span)).Count != changes.Length, "'changes' was not normalized.");

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

52=> $"project: ({project.Id}), ({string.Join(Environment.NewLine, analyzers.Select(a => a.ToString()))})";

EditAndContinue\DebuggingSessionTelemetry.cs (2)

118map["ProjectIdsWithAppliedChanges"] = editSessionData.Committed ? editSessionData.ProjectsWithValidDelta.Select(ProjectIdToPii) : ""; 121map["ProjectIdsWithUpdatedBaselines"] = editSessionData.ProjectsWithUpdatedBaselines.Select(ProjectIdToPii);

EditAndContinue\DocumentAnalysisResults.cs (1)

153Debug.Assert(lineEditsOpt.Select(edit => edit.FileName).Distinct().Count() == lineEditsOpt.Length);

EditAndContinue\EmitSolutionUpdateResults.cs (3)

190Debug.Assert(diagnostics.Select(re => re.ProjectId).IsSorted()); 196.Intersect(moduleUpdates.Select(u => u.ProjectId)) 284updatedProjects.AddRange(moduleUpdates.Select(static u => u.ProjectId));

EditAndContinue\SolutionUpdate.cs (2)

55$"types=[{string.Join(",", moduleUpdate.UpdatedTypes.Select(token => token.ToString("X8")))}], " + 56$"methods=[{string.Join(",", moduleUpdate.UpdatedMethods.Select(token => token.ToString("X8")))}]");

EmbeddedLanguages\EmbeddedLanguageCommentDetector.cs (1)

27var namePortion = string.Join("|", identifiers.Select(n => $"({Regex.Escape(n)})"));

EncapsulateField\AbstractEncapsulateFieldService.cs (1)

238linkedProjectIds.AddRange(linkedDocumentIds.Select(d => d.ProjectId));

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (1)

61Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1);

ExtractClass\ExtractClassWithDialogCodeAction.cs (1)

73extractClassOptions.MemberAnalysisResults.Select(m => m.Member),

ExtractMethod\MethodExtractor.CodeGenerator.cs (1)

286(TExpressionSyntax)generator.TupleExpression(expressions.Select(generator.Argument));

FindUsages\AbstractFindUsagesService_FindImplementations.cs (1)

146result.AddRange(implementations.Select(s => s.OriginalDefinition));

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (1)

107var parameters = _state.Parameters.Select(p => _service.ToDisplayString(p, SimpleFormat));

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.FieldDelegatingCodeAction.cs (1)

89var parameters = _state.Parameters.Select(p => _service.ToDisplayString(p, SimpleFormat));

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.State.cs (4)

61var mappedMembers = selectedMembers.Select(m => TryMapToWritableInstanceFieldOrProperty(service, m, cancellationToken)).Distinct().ToImmutableArray(); 108let constructorTypes = c.Parameters.Select(p => p.Type) 120=> parameters.Select(p => p.Type).SequenceEqual(constructor.Parameters.Select(p => p.Type));

InheritanceMargin\InheritanceMarginItem.cs (1)

59=> string.Join("", DisplayTexts.Select(d => d.Text));

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (3)

254.Select(parameterAndArguments => CreateLocalDeclarationStatement(syntaxGenerator, renameTable, parameterAndArguments)); 257.Select(parameterAndName => 338.Select(parameterAndName => (parameter: (ISymbol)parameterAndName.parameter,

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

722return symbolGroup.Select(s => s.OriginalDefinition)

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (2)

57.Select(symbol => symbol.Locations.FirstOrDefault()) 203.Select(node => root.GetCurrentNode(node))

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

73Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1);

NavigateTo\AbstractNavigateToSearchService.GeneratedDocumentSearch.cs (1)

34Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1);

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (2)

159Contract.ThrowIfTrue(projects.Select(p => p.Language).Distinct().Count() != 1); 202using var _ = GetPooledHashSet(priorityDocuments.Select(d => d.Project), out var highPriProjects);

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

258var sourceFileInfoTasks = sourceDocuments.Select(sd => _pdbSourceDocumentLoaderService.LoadSourceDocumentAsync(tempFilePath, sd, encoding, telemetryMessage, useExtendedTimeout, cancellationToken)).ToArray();

PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (1)

66.. allDestinations.Select(destination => MembersPuller.TryComputeCodeAction(document, selectedMembers, destination))

QuickInfo\QuickInfoSection.cs (1)

57Interlocked.CompareExchange(ref _text, string.Concat(TaggedParts.Select(t => t.Text)), null);

Shared\Extensions\ISymbolExtensions_Sorting.cs (1)

135return [.. GetMethodOrIndexerOrEventParameters(symbol).Select(p => p.Type.ToMinimalDisplayString(semanticModel, position))];

src\Analyzers\Core\Analyzers\AbstractBuiltInUnnecessaryCodeStyleDiagnosticAnalyzer.cs (2)

106AddDescriptorsToFadingOptionMapping(supportedDiagnosticsWithOptions.Select(static item => item.Descriptor), fadingOption); 115AddDescriptorsToFadingOptionMapping(supportedDiagnosticsWithOptions.Select(static item => item.Descriptor), fadingOption);

src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

661foreach (var tree in namedTypeSymbol.Locations.Select(l => l.SourceTree).Distinct().WhereNotNull())

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

187if (!namedType.DeclaringSyntaxReferences.Select(d => d.SyntaxTree).Distinct().Any(tree =>

src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerDiagnosticAnalyzer.cs (1)

175nodes = nodes.AddRange(matches.Select(static m => m.Node));

src\Analyzers\Core\Analyzers\UseObjectInitializer\AbstractUseObjectInitializerDiagnosticAnalyzer.cs (1)

119var nodes = ImmutableArray.Create<SyntaxNode>(containingStatement).AddRange(matches.Select(m => m.Statement));

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

365var parameters = methodToUpdate.Parameters.Select(p => p.ToDisplayString(SimpleFormat)); 440methodParameterNames.AddRange(method.Parameters.Select(p => p.Name));

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

232var uniqueName = NameGenerator.EnsureUniqueness(argumentNameSuggestion, method.Parameters.Select(p => p.Name));

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

161[.. delegatedConstructor.Parameters.Select(p => p.Name)], 167if (delegatedConstructor.Parameters.Select(p => p.Name).Intersect(remainingParameterNames.Select(n => n.BestNameForParameter)).Any()) 221constructor.Parameters.Select(p => p.Type).SequenceEqual(ParameterTypes))

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.cs (1)

55string.Join(", ", constructor.Parameters.Select(p => p.Name))),

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeAction.cs (1)

38_constructors.Select(CreateConstructorDefinition),

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

203var types = await SpecializedTasks.WhenAll(DetermineParameterTypes(cancellationToken).Select(t => FixTypeAsync(t, cancellationToken))).ConfigureAwait(false);

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

45Debug.Assert(diagnostics.Select(diagnostic => diagnostic.Properties[MatchFolderAndNamespaceConstants.TargetNamespace]).Distinct().Count() == 1);

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

846var spansToFormat = originalDeclStatementsToMoveOrRemove.Select(s => s.Span);

UnusedReferences\ProjectAssets\ProjectAssetsReader.cs (1)

62.Select(projectReference => EnhanceReference(projectAssets, projectReference, autoReferences, targetLibraryKeys, builtReferences))

ValueTracking\ValueTracker.OperationCollector.cs (1)

196.Select(pair => pair.collector.ProgressCollector)

EditAndContinue\EditAndContinueTestVerifier.cs (1)

324expectedSemanticEdits.Select(e => $"{e.Kind}: {e.SymbolProvider((e.Kind == SemanticEditKind.Delete ? oldCompilation : newCompilation))}"),

EditAndContinue\EditAndContinueWorkspaceTestBase.cs (2)

262=> actual.Select(InspectDiagnostic); 280=> actual.Select(InspectDiagnostic);

EditAndContinue\EditScriptDescription.cs (1)

35=> AssertEx.Equal(expected, Edits.Select(e => e.Kind));

Extensions\Extensions.cs (1)

197var additionalDocuments = documentIds.Select(solution.GetAdditionalDocument).WhereNotNull().ToImmutableArray();

Extensions\ProtocolConversions.cs (1)

420var mappedResults = await GetMappedSpanResultAsync(oldDocument, [.. textChanges.Select(tc => tc.Span)], cancellationToken).ConfigureAwait(false);

Features\UnifiedSuggestions\UnifiedSuggestedActionsSource.cs (1)

465=> [.. refactorings.Select(r => FilterOnAnyThread(r, selection, filterOutsideSelection)).WhereNotNull()];

Handler\Formatting\FormatDocumentOnTypeHandler.cs (1)

105return [.. textChanges.Select(change => ProtocolConversions.TextChangeToTextEdit(change, documentSyntax.Text))];

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

112return ReadCodeSnippetElements(document)?.Select(element => new CodeSnippet(element)).ToImmutableArray();

Completion\CompletionFeaturesTests.cs (3)

414var defaultCharArray = CompletionRules.Default.DefaultCommitCharacters.Select(c => c.ToString()).ToArray(); 462var defaultCharArray = CompletionRules.Default.DefaultCommitCharacters.Select(c => c.ToString()).ToArray(); 805var defaultCharArray = CompletionRules.Default.DefaultCommitCharacters.Select(c => c.ToString()).ToArray();

Diagnostics\PullDiagnosticTests.cs (1)

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

SpellCheck\SpellCheckTests.cs (1)

544.SelectMany(kvp => kvp.Value.Select(textSpan => (kind: kvp.Key, textSpan))

Utilities\AbstractLanguageServerClientTests.cs (1)

100locationsForName.AddRange(spans.Select(span => ConvertTextSpanWithTextToLocation(span, text, codeUri)));

DeclarePublicApiAnalyzer.Impl.cs (2)

337overload.Parameters.Select(p => p.Type).SequenceEqual(method.Parameters.Select(p => p.Type)))

CSharpRebuildTests.cs (1)

38.Select(x => compilationFactory.CreateSyntaxTree(x.FilePath, x.GetText()))

Services\SymbolFinder\RemoteSymbolFinderService.cs (1)

61documentArgs.Select(solution.GetDocument).WhereNotNull().ToImmutableHashSet();

GlobalAssemblyCacheTests.cs (1)

110var gacLocationsUpper = GlobalAssemblyCacheLocation.RootLocations.Select(location => location.ToUpper());

BaseCompilerFeatureRequiredTests.cs (1)

19var featureLengthAndName = string.Join(" ", builder.ToImmutableArray().Select(b => $"{b:x2}"));

Compilation\CompilationDifference.cs (1)

178EmitResult.UpdatedMethods.Select(methodHandle => $"0x{MetadataTokens.GetToken(methodHandle):X8}"));

Compilation\CompilationExtensions.cs (2)

90Assert.True(emitResult.Success, "Diagnostics:\r\n" + string.Join("\r\n", emitResult.Diagnostics.Select(d => d.ToString()))); 104Assert.True(emitResult.Success, "Diagnostics: " + string.Join(", ", emitResult.Diagnostics.Select(d => d.ToString())));

Diagnostics\CommonDiagnosticAnalyzers.cs (1)

2824var trees = symbol.DeclaringSyntaxReferences.Select(syntaxRef => syntaxRef.SyntaxTree).Distinct();

Platform\Desktop\DesktopRuntimeEnvironment.cs (2)

87.GetMissing(runtimeModuleDataList.Select(x => new RuntimeModuleDataId(x.Id)).ToList()) 224var searchIds = Modules.Select(x => new RuntimeModuleDataId(x.Id)).ToList();

Analyzers\AnalyzerFileReferenceTests.cs (11)

127var analyzerNames = analyzers.Select(a => a.GetType().Name); 134analyzerNames = analyzers.Select(a => a.GetType().Name); 369var typeNames = generators.Select(g => g.GetGeneratorType().FullName); 407var typeNames = generators.Select(g => g.GetGeneratorType().FullName); 429var typeNames = generators.Select(g => g.GetGeneratorType().FullName); 519var csharpAnalyzers = reference.GetAnalyzers(LanguageNames.CSharp).Select(a => a.GetType().FullName).ToArray(); 526var vbAnalyzers = reference.GetAnalyzers(LanguageNames.VisualBasic).Select(a => a.GetType().FullName).ToArray(); 534var allAnalyzers = reference.GetAnalyzersForAllLanguages().Select(a => a.GetType().FullName).ToArray(); 552var csharpGenerators = reference.GetGenerators(LanguageNames.CSharp).Select(g => g.GetGeneratorType().FullName).ToArray(); 565var vbGenerators = reference.GetGenerators(LanguageNames.VisualBasic).Select(g => g.GetGeneratorType().FullName).ToArray(); 574var allGenerators = reference.GetGeneratorsForAllLanguages().Select(g => g.GetGeneratorType().FullName).ToArray();

AssemblyUtilitiesTests.cs (1)

131var results = AssemblyUtilities.IdentifyMissingDependencies(_testFixture.Alpha, new[] { _testFixture.Alpha }).Select(identity => identity.Name);

FlowAnalysis\FlowTestBase.vb (13)

Editing\SymbolEditor.cs (1)

195.Select(sr => sr.GetSyntax())

Editing\SyntaxGenerator.cs (18)

193typeParameters: method.TypeParameters.Select(p => TypeParameter(p)), 194parameters: method.Parameters.Select(p => ParameterDeclaration(p)), 286parameters: method.Parameters.Select(p => ParameterDeclaration(p)), 452indexer.Parameters.Select(p => this.ParameterDeclaration(p)), 528var parameters = invoke?.Parameters.Select(p => this.ParameterDeclaration(p)); 561constructorMethod.Parameters.Select(p => ParameterDeclaration(p)), 763type.TypeParameters.Select(TypeParameter), 767interfaceTypes: type.Interfaces.Select(TypeExpression), 772type.TypeParameters.Select(TypeParameter), 775interfaceTypes: type.Interfaces.Select(TypeExpression), 779type.TypeParameters.Select(TypeParameter), 781interfaceTypes: type.Interfaces.Select(TypeExpression), 793typeParameters: type.TypeParameters.Select(TypeParameter), 794parameters: invoke.Parameters.Select(p => ParameterDeclaration(p)), 864declaration = WithTypeParameters(declaration, typeParameters.Select(tp => TypeParameter(tp))); 875types: tp.ConstraintTypes.Select(TypeExpression)); 1024var args = attribute.ConstructorArguments.Select(a => this.AttributeArgument(this.TypedConstantExpression(a))) 1025.Concat(attribute.NamedArguments.Select(n => this.AttributeArgument(n.Key, this.TypedConstantExpression(n.Value))))

FindSymbols\FindReferences\DependentProjectsFinder.cs (1)

93result.AddRange(filteredProjects.Select(p => p.project));

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

97var parameterNode = parameter.DeclaringSyntaxReferences.Select(r => r.GetSyntax(cancellationToken)).FirstOrDefault(); 108var lambdaNode = parameter.ContainingSymbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax(cancellationToken)).First(); 148var lambdaNode = symbol.ContainingSymbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax(cancellationToken)).First();

FindSymbols\SymbolTree\SymbolTreeInfo.cs (1)

300=> new(sortedNodes.Select(n => n.Name));

ReassignedVariable\AbstractReassignedVariableService.cs (1)

272.Select(r => r.GetSyntax(cancellationToken))

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

241.Select(l => conflictResolution.OldSolution.GetRequiredDocument(l.SourceTree!)) 474return [.. _nonConflictSymbolKeys.Select(s => s.Resolve(compilation).GetAnySymbol()).WhereNotNull()]; 709var allRenamedDocuments = _renameLocationSet.Locations.Select(loc => loc.Location.SourceTree!).Distinct().Select(solution.GetRequiredDocument);

Rename\SymbolicRenameLocations.cs (1)

145var referencedSymbols = referenceSymbols.Select(r => r.Definition).Where(r => !r.Equals(symbol)).ToImmutableArray();

Serialization\SerializedPortableExecutableReference.cs (1)

66Guids={modules.Select(m => GetMetadataGuid(m).ToString()).Join(",")}

Shared\Extensions\IMethodSymbolExtensions.cs (4)

68!method1.Parameters.Select(p => p.Name).SequenceEqual(method2.Parameters.Select(p => p.Name))) 83return p1.Select(p => p.Type).ToList().AreMoreSpecificThan([.. p2.Select(p => p.Type)]);

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

44.Select(section => (matchKind: section.GetMatchKind(language), section))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.cs (1)

432=> _relativeIndentationTree.Algorithms.GetIntervalsThatIntersectWith(this.TreeData.StartPosition, this.TreeData.EndPosition, new FormattingContextIntervalIntrospector()).Select(i => i.Operation);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (3)

307return string.Join(", ", symbols.Select(symbol => symbol.ToEditorConfigString())); 405return string.Join(", ", accessibilities.Select(accessibility => accessibility.ToEditorConfigString(languageName))); 464return string.Join(", ", modifiers.Select(modifier => modifier.ToEditorConfigString(languageName)));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (3)

350new XElement("SymbolSpecifications", SymbolSpecifications.Select(s => s.CreateXElement())), 351new XElement("NamingStyles", NamingStyles.Select(n => n.CreateXElement())), 352new XElement("NamingRules", SerializableNamingRules.Select(n => n.CreateXElement())));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

98selectedMembers.AddRange(GetDeclaratorsAndIdentifiers(member).Select(pair => pair.declarator));

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

602var declarationSyntax = symbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).FirstOrDefault();

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

15=> typeParameter.ConstraintTypes.Select(GetNamedTypeSymbol).WhereNotNull().FirstOrDefault();

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

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();

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

112symbols.AddRange(interfaceType.AllInterfaces.Select(i => i.OriginalDefinition));

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

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this));

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

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();

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

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamedTypeSymbol.cs (1)

87return this.GetMembers().Select(m => m.Name).ToList();

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\DocumentExtensions.cs (1)

192var diagnostics = string.Join(", ", errors.Select(d => d.ToString()));

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

28.Select(tp => tp.Name) 45if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames)) 79if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

18if (parameterList.Select(p => p.Name).SequenceEqual(parameterNames))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ITypeInferenceServiceExtensions.cs (1)

49var delegateTypes = types.Select(t => t.GetDelegateType(semanticModel.Compilation));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (1)

159IEnumerable<(TType instance, (TNode semanticNode, IEnumerable<TNode> additionalNodes) nodes)> originalNodePairs = originalNodes.Select(n => (n, selector(n)));

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

85.Select(t => t.InferredType) 97.Select(info => info.InferredType)

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

142=> [.. services.Select(s => (s.Metadata.ServiceType, s.Metadata.Layer))];

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

216=> [.. services.Select(s => (s.Metadata.ServiceType, s.Metadata.Layer))];

Storage\SQLite\v2\SQLitePersistentStorage.Accessor.cs (5)

72({string.Join(",", _allColumns.Select(c => c.name))}) values ({string.Join(",", _allColumns.Select(n => "?"))}) 80{string.Join(" and ", _primaryKeyColumns.Select(k => $"{k.name} = ?"))} 113{string.Join(",", _allColumns.Select(k => $"{k.name} {k.type} not null"))}, 114primary key({string.Join(",", _primaryKeyColumns.Select(k => k.name))})

Workspace\CommandLineProject.cs (1)

73foreach (var path in commandLineArguments.AnalyzerReferences.Select(r => r.FilePath))

Workspace\DocumentTracking\IDocumentTrackingServiceExtensions.cs (1)

29.Select(solution.GetDocument)

Workspace\ProjectSystem\ProjectSystemProject.BatchingDocumentCollection.cs (1)

597documentIds: documentsAddedInBatch.Select(d => d.Id));

Workspace\Solution\SolutionCompilationState.cs (1)

111.Select(static projectState => projectState.Id)

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

191.Select(static dt => dt.tree));

Workspace\Solution\SolutionState.cs (3)

168Debug.Assert(SortedProjectStates.Select(static state => state.Id).SetEquals(ProjectIds)); 169Debug.Assert(SortedProjectStates.Select(static state => state.Id).SetEquals(_dependencyGraph.ProjectIds)); 1217var map = sortedNewProjectStates.Select(state => KeyValuePairUtil.Create(

Workspace\Solution\TextDocumentStates.cs (1)

152States.AddRange(states.Select(state => KeyValuePairUtil.Create(state.Id, state))),

Workspace\Workspace.cs (1)

1087foreach (var projectId in data.documentInfos.Select(i => i.Id.ProjectId).Distinct())

MSBuild\MSBuildProjectLoader.Worker.cs (1)

418foreach (var path in commandLineArgs.AnalyzerReferences.Select(r => r.FilePath))

NetCoreTests.cs (1)

539Assert.Contains("LibraryHelperClass = Library.MyHelperClass", option.GlobalImports.Select(i => i.Name));

VisualStudioMSBuildWorkspaceTests.cs (1)

1833actual: imports.Select(i => i.Name));

Options\NamingStyleTestUtilities.cs (1)

28=> string.Join(",", items.Select(item => item.ToString()));

UtilityTest\IntervalTreeTests.cs (15)

SignToolTests.cs (3)

392signingInput.FilesToSign.Select(f => f.ToString()).Should().BeEquivalentTo(expected); 393signingInput.FilesToCopy.Select(f => $"{f.Key} -> {f.Value}").Should().BeEquivalentTo(expectedCopyFiles ?? Array.Empty<string>()); 2609task.ParsedSigningInput.FilesToSign.Select(f => f.ToString()).Should().BeEquivalentTo(expected);

Parsers\ValidationsGenerator.TypesParser.cs (1)

208Arguments: [.. attribute.ConstructorArguments.Select(a => a.ToCSharpString())],

src\Shared\RoslynUtils\SymbolExtensions.cs (1)

223var parameterTypes = constructor.Parameters.Select(parameter => $"typeof({parameter.Type.ToDisplayString()})");

Parser.cs (2)

57type.Definitions.Select(def => Diagnostic.Create(DiagDescriptors.ContextMustBePartial, def.Identifier.GetLocation(), type.Name))); 68type.Definitions.Select(def => Diagnostic.Create(DiagDescriptors.ContextDoesNotHaveValidProperties, def.Identifier.GetLocation(), type.Name)));

Parsing\Parser.cs (2)

326lt.AllMembers.AddRange(methodSymbol.ContainingType.GetMembers().Select(x => x.Name)); 473.Select(static attribute => attribute.AttributeClass)

AttributeInfo.cs (1)

28var args = attribute.ConstructorArguments.Select(ca => ca.ToCSharpString());

ComMethodInfo.cs (1)

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

VirtualMethodPointerStubGenerator.cs (1)

161methodStub.CallingConvention.Array.Select(callConv => TypeOfExpression(TypeSyntaxes.CallConv(callConv.Name.ValueText)))))))

JSManagedTypeInfo.cs (2)

148.Select(arg => CreateJSTypeInfoForTypeSymbol(arg) as JSSimpleTypeInfo) 159.Select(argName => CreateJSTypeInfoForTypeSymbol(argName) as JSSimpleTypeInfo)

BoundGenerators.cs (1)

210NativeParameterMarshallers.Select(marshaler => marshaler.AsParameter(context)))),

Transforms\Normalizer.cs (1)

497public IEnumerator<IColumnFunction> GetEnumerator() => _infos.Select(info => info.ColumnFunction).GetEnumerator();

Dynamic\Trainers\BinaryClassification\PermutationFeatureImportance.cs (1)

58var auc = permutationMetrics.Select(x => x.AreaUnderRocCurve).ToArray();

Dynamic\Trainers\BinaryClassification\PermutationFeatureImportanceLoadFromDisk.cs (1)

57var auc = permutationMetrics.Select(x => x.AreaUnderRocCurve).ToArray();

Dynamic\Trainers\MulticlassClassification\PermutationFeatureImportance.cs (1)

61var microAccuracy = permutationMetrics.Select(x => x.MicroAccuracy)

Dynamic\Trainers\MulticlassClassification\PermutationFeatureImportanceLoadFromDisk.cs (1)

69var microAccuracy = permutationMetrics.Select(x => x.MicroAccuracy)

Dynamic\Trainers\Ranking\PermutationFeatureImportance.cs (1)

63var ndcg = permutationMetrics.Select(

Dynamic\Trainers\Ranking\PermutationFeatureImportanceLoadFromDisk.cs (1)

70var ndcg = permutationMetrics.Select(

Dynamic\Trainers\Regression\PermutationFeatureImportance.cs (1)

66var rmse = permutationMetrics.Select(x => x.RootMeanSquaredError)

Dynamic\Trainers\Regression\PermutationFeatureImportanceLoadFromDisk.cs (1)

73var rmse = permutationMetrics.Select(x => x.RootMeanSquaredError)

TensorflowTransform.cs (2)

572var colTypeDims = vecType.Dimensions.Select(dim => (int)dim).ToArray(); 582var colTypeDims = vecType.Dimensions.Select(dim => (int)dim).ToArray();

Text\NgramHashingTransformer.cs (1)

227string[][] friendlyNames = _columns.Select(c => c.FriendlyNames).ToArray();

DnnRetrainTransform.cs (1)

793var colTypeDims = vecType.Dimensions.Select(dim => (int)dim).ToArray();

CallHierarchy\CallHierarchyItem.cs (1)

107return _finders.Select(s => new CallHierarchySearchCategory(s.SearchCategory, s.DisplayName));

CallHierarchy\Finders\ImplementerFinder.cs (1)

42var sourceLocations = implementation.DeclaringSyntaxReferences.Select(d => project.Solution.GetDocument(d.SyntaxTree)).WhereNotNull();

CallHierarchy\Finders\OverridingMemberFinder.cs (1)

38var sourceLocations = @override.DeclaringSyntaxReferences.Select(d => project.Solution.GetDocument(d.SyntaxTree)).WhereNotNull();

ColorSchemes\ColorSchemeApplier.RegistryItemConverter.cs (1)

23return [.. scheme.Themes.Select(ToRegistryItem)];

Implementation\VisualStudioSupportsFeatureService.cs (1)

114return ids.Select(id => ContainedDocument.TryGetContainedDocument(id))

MoveToNamespace\MoveToNamespaceDialogViewModel.cs (1)

31.. namespaceHistory.Select(n => new NamespaceItem(true, n))

PickMembers\PickMembersDialogViewModel.cs (2)

36_allMembers = [.. members.Select(m => new MemberSymbolViewModel(m, glyphService))]; 38Options = [.. options.Select(o => new OptionViewModel(o))];

ProjectSystem\VisualStudioWorkspaceImpl.OpenFileTracker.cs (1)

286var activeProjectId = GetActiveContextProjectIdAndWatchHierarchies_NoLock(moniker, documentIds.Select(d => d.ProjectId), hierarchy);

ProjectSystem\VisualStudioWorkspaceImpl_SourceGenerators.cs (1)

72foreach (var projectId in documentIds.Select(i => i.ProjectId).Distinct())

PullMemberUp\SymbolDependentsBuilder.cs (1)

58var tasks = _declarationService.GetDeclarations(_member).Select(@ref => @ref.GetSyntaxAsync(_cancellationToken));

StackTraceExplorer\FrameViewModel.cs (1)

40public string AutomationName => string.Join("", Inlines.Select(InlineExtensions.GetText));

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

38.Select(update => new UnusedReferencesEntry(solutionName, project.Name, project.Language, update))

UnusedReferences\VisualStudioReferenceCleanupService.cs (1)

35return [.. projectSystemReferences.Select(reference => reference.ToReferenceInfo())];

Venus\ContainedDocument.DocumentServiceProvider.cs (1)

78var mappedSpanResults = await MapSpansAsync(oldDocument, textChanges.Select(tc => tc.Span), CancellationToken.None).ConfigureAwait(false);

Venus\ContainedLanguageCodeSupport.cs (3)

69var reservedNames = semanticModel.LookupSymbols(point.Value.Position, type).Select(m => m.Name); 269var memberNode = member.DeclaringSyntaxReferences.Select(r => r.GetSyntax(cancellationToken)).FirstOrDefault(); 449return string.Format("{0}({1})", member.Name, string.Join(",", ((IMethodSymbol)member).Parameters.Select(p => p.Type.ToDisplayString())));

Implementation\LanguageClient\XamlCapabilities.cs (1)

23AllCommitCharacters = [.. RoslynCompletion.CompletionRules.Default.DefaultCommitCharacters.Select(c => c.ToString())]

EditAndContinue\EditAndContinueTestUtilities.cs (1)

110AssertEx.Equal(expectedNames, entityHandles.Select(handle =>

Remote\SerializationValidator.cs (1)

69public IEnumerator<T> GetEnumerator() => Children.Select(t => t).GetEnumerator();

AssemblyScheduler.cs (2)

110kvp => kvp.Value.Select(WithTypeExecutionTime).ToImmutableArray()); 117var tests = typeInfo.Tests.Select(WithTestExecutionTime).ToImmutableArray();

HelixTestRunner.cs (2)

75var helixWorkItems = AssemblyScheduler.Schedule(assemblies.Select(x => x.AssemblyPath), testHistory); 206.Select(x => Path.GetRelativePath(binDir, x))

Helpers\RoslynExtensions.cs (2)

69.Select(e => compilation.EraseCompileTimeMetadata(e.Type)) 93.Select(compilation.EraseCompileTimeMetadata)

System\Resources\Tools\CodeDomCompileHelper.cs (1)

55throw new InvalidOperationException(string.Join('\n', result.Diagnostics.Select(d => d.GetMessage())));