Distinct

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

79.Distinct()

Microsoft.CodeAnalysis.CSharp (2)

Symbols\SubstitutedNamedTypeSymbol.cs (2)

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

Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (1)

Formatting\CodeCleanupTests.cs (1)

637Assert.Equal(supportedDiagnostics, supportedDiagnostics.Distinct());

Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (1)

Diagnostics\DiagnosticAnalyzerTests.cs (1)

4153var syntaxKinds = baseListNode.DescendantNodesAndSelf().Select(node => node.Kind()).Distinct().AsImmutable();

Microsoft.CodeAnalysis.CSharp.Features (1)

EditAndContinue\DeclarationBody\OrdinaryInstanceConstructorWithExplicitInitializerDeclarationBody.cs (1)

30=> model.AnalyzeDataFlow(Initializer)!.CapturedInside.AddRange(model.AnalyzeDataFlow(Body).CapturedInside).Distinct();

Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (1)

Semantics\ImportsTests.cs (1)

144var externAliases = compilationUnits.SelectMany(cu => cu.Externs).Select(e => e.Identifier.ValueText).Distinct();

Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (2)

Symbols\Source\BaseClassTests.cs (2)

1072var B1 = global1.GetTypeMembers("ClassB", 0).Distinct().Single(); 1188var B1 = global1.GetTypeMembers("ClassB", 0).Distinct().Single();

Microsoft.CodeAnalysis.CSharp.Test.Utilities (1)

CompilationTestUtils.cs (1)

350return symbols.Select(s => s.Name).Distinct().ToList();

Microsoft.CodeAnalysis.CSharp.Workspaces (1)

Rename\CSharpRenameRewriterLanguageService.cs (1)

864AddConflictingParametersOfProperties(properties.Distinct(), replacementText, conflicts);

Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (1)

Completion\AbstractCompletionProviderTests.cs (1)

307Assert.Equal(matchingFilters.Count, matchingFilters.Distinct().Count());

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (2)

Diagnostics\IDEDiagnosticIDUniquenessTest.cs (1)

21Assert.Equal(listOfIDEDiagnosticIds.Count, listOfIDEDiagnosticIds.Distinct().Count());

Workspaces\ClassificationTypeNamesTests.cs (1)

46=> Assert.Equal(ClassificationTypeNames.AllTypeNames.Distinct(), ClassificationTypeNames.AllTypeNames);

Microsoft.CodeAnalysis.ExternalAccess.FSharp (2)

Internal\NavigateTo\FSharpNavigateToSearchService.cs (1)

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

SignatureHelp\FSharpSignatureHelpItems.cs (1)

82var distinctItems = items.Distinct().ToList();

Microsoft.CodeAnalysis.Features (20)

AddImport\SymbolReferenceFinder.cs (1)

141.Distinct()

EditAndContinue\EmitSolutionUpdateResults.cs (1)

263.Distinct()

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (1)

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

FullyQualify\AbstractFullyQualifyService.cs (2)

100.Distinct() 312=> symbols.Distinct()

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.State.cs (1)

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

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (1)

283.Distinct()

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.GeneratedDocumentSearch.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (1)

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

Organizing\AbstractOrganizingService.cs (1)

41select o).Distinct();

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)

190var allReferenceDocuments = getReferencesByDocument.Concat(setReferencesByDocument).Select(g => g.Key).Distinct();

SignatureHelp\SignatureHelpItems.cs (1)

77var distinctItems = items.Distinct().ToList();

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

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

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

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

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

155.Distinct()

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

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

UnusedReferences\ProjectAssets\ProjectAssetsReader.cs (1)

50.Distinct()

Wrapping\AbstractCodeActionComputer.cs (2)

226var tokens = leftTokenToTrailingTrivia.Keys.Concat(rightTokenToLeadingTrivia.Keys).Distinct().ToImmutableArray(); 246tokens: leftTokenToTrailingTrivia.Keys.Concat(rightTokenToLeadingTrivia.Keys).Distinct(),

Microsoft.CodeAnalysis.Features.Test.Utilities (1)

RelatedDocuments\AbstractRelatedDocumentsTests.cs (1)

45Assert.True(results.Distinct().Count() == results.Count);

Microsoft.CodeAnalysis.Features.UnitTests (1)

EditAndContinue\RudeEditDiagnosticTests.cs (1)

116AssertEx.Equal(allKinds, allKinds.Distinct());

Microsoft.CodeAnalysis.LanguageServer (1)

HostWorkspace\ProjectDependencyHelper.cs (1)

133var unresolvedParams = new UnresolvedDependenciesParams([.. projectPaths.Distinct()]);

Microsoft.CodeAnalysis.LanguageServer.Protocol (1)

Handler\Diagnostics\BuildOnlyDiagnosticIdsHandler.cs (1)

45foreach (var languageName in context.Solution.Projects.Select(p => p.Language).Distinct())

Microsoft.CodeAnalysis.Scripting (2)

src\Compilers\Shared\GlobalAssemblyCacheHelpers\ClrGlobalAssemblyCache.cs (1)

121return q.Distinct();

src\Compilers\Shared\GlobalAssemblyCacheHelpers\MonoGlobalAssemblyCache.cs (1)

162Select(identityAndPath => identityAndPath.Identity.Name).Distinct();

Microsoft.CodeAnalysis.Test.Utilities (6)

Diagnostics\CommonDiagnosticAnalyzers.cs (1)

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

Diagnostics\ThrowingDiagnosticAnalyzer.cs (1)

81var diagnostics = (await runAnalysis(analyzer)).Distinct();

Diagnostics\TrackingDiagnosticAnalyzer.cs (4)

76var actualMembers = _callLog.Select(e => e.CallerName).Distinct(); 87var actualSymbolKinds = _callLog.Where(a => FilterByAbstractName(a, "Symbol")).Where(e => e.SymbolKind.HasValue).Select(e => e.SymbolKind.Value).Distinct(); 145.Select(e => new { SymbolKind = e.SymbolKind.Value, MethodKind = e.MethodKind ?? InvalidMethodKind, e.ReturnsVoid }).Distinct(); 147.Select(e => new { SymbolKind = e.SymbolKind.Value, MethodKind = e.MethodKind ?? InvalidMethodKind, e.ReturnsVoid }).Distinct();

Microsoft.CodeAnalysis.Workspaces (17)

CodeFixes\FixAllOccurrences\TextChangeMerger.cs (1)

72var changesToApply = _totalChangesIntervalTree.Distinct().OrderBy(tc => tc.Span.Start);

FindSymbols\SymbolTree\SymbolTreeInfoCacheService.cs (1)

152foreach (var reference in project.MetadataReferences.OfType<PortableExecutableReference>().Distinct())

Rename\ConflictEngine\ConflictResolver.cs (1)

154foreach (var language in projectIds.Select(p => solution.GetRequiredProject(p).Language).Distinct())

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

715foreach (var language in documentsFromAffectedProjects.Select(d => d.Project.Language).Distinct())

Rename\RenameUtilities.cs (2)

95.Select(d => d.ProjectId).Distinct(); 109solution.GetProjectDependencyGraph().GetProjectsThatDirectlyDependOnThisProject(p))).Distinct();

Shared\Extensions\ILanguageMetadataExtensions.cs (1)

51foreach (var language in service.Metadata.Languages.Distinct())

Shared\Utilities\SemanticMap.cs (1)

35return _expressionToInfoMap.Values.Concat(_tokenToInfoMap.Values).Select(info => info.Symbol).Distinct();

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

385interfaces.SelectMany(i => i.GetAllInterfacesIncludingThis()).Distinct());

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

272var tokens = node.GetAnnotatedTrivia(SyntaxAnnotation.ElasticAnnotation).Select(tr => tr.Token).Distinct();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser.cs (1)

120.Distinct();

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (1)

221var orderedTokens = tokens.Distinct().OrderBy(t => t.SpanStart);

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

79.Distinct()

Workspace\CommandLineProject.cs (2)

65var boundMetadataReferences = commandLineArguments.ResolveMetadataReferences(commandLineMetadataReferenceResolver).Distinct().ToList(); 78var boundAnalyzerReferences = commandLineArguments.ResolveAnalyzerReferences(analyzerLoader).Distinct().ToList();

Workspace\DocumentTracking\IDocumentTrackingServiceExtensions.cs (1)

31.Distinct()

Workspace\Host\Mef\MefHostServices.cs (1)

50var compositionConfiguration = new ContainerConfiguration().WithAssemblies(assemblies.Distinct());

Microsoft.DotNet.Arcade.Sdk (2)

src\GenerateResxSource.cs (1)

508.Distinct();

src\SourceBuild\AddSourceMappingToNugetConfig.cs (1)

52.Distinct()

Microsoft.DotNet.Arcade.Sdk.Tests (1)

SourceMappingToNugetConfigTest.cs (1)

66.Distinct()

Microsoft.DotNet.Build.Tasks.Feed (3)

src\model\SetupTargetFeedConfigV3.cs (1)

86return Feeds().Distinct().ToList();

src\PublishArtifactsInManifestBase.cs (1)

729string[] symbolPackagesAssetNames = buildAssets?.Keys.Where(x => IsSymbolPackage(x)).Distinct().ToArray() ?? [];

src\PublishArtifactsInManifestV3.cs (1)

108foreach (var targetChannelId in targetChannelsIds.Distinct())

Microsoft.DotNet.Build.Tasks.Packaging (6)

GetApplicableAssetsFromPackageReports.cs (1)

94BuildProjects = buildProjects.Distinct().Select(bp => bp.ToItem()).ToArray();

GetApplicableAssetsFromPackages.cs (1)

142BuildProjects = buildProjects.Distinct().Select(bp => bp.ToItem()).ToArray();

PackageIndex.cs (1)

258return Packages.Values.SelectMany(info => info.InboxOn.GetInboxFrameworks()).Distinct().ToArray();

SplitDependenciesBySupport.cs (1)

45.Distinct()

UpdatePackageIndex.cs (2)

221var dllNames = dlls.Select(f => Path.GetFileNameWithoutExtension(f)).Distinct(); 257dllNames = dlls.Select(f => Path.GetFileNameWithoutExtension(f)).Distinct().ToArray();

Microsoft.DotNet.Build.Tasks.VisualStudio (2)

OptProf\GetRunSettingsSessionConfiguration.cs (2)

136.Distinct() 154.Distinct()

Microsoft.DotNet.GenFacades (1)

GenPartialFacadeSourceGenerator.cs (1)

37string[] distinctSeeds = seeds.Select(seed => Path.GetFullPath(seed)).Distinct().ToArray();

Microsoft.DotNet.NuGetRepack.Tasks (1)

src\UpdatePackageVersionTask.cs (1)

91File.WriteAllLines(Path.Combine(OutputDirectory, "PreReleaseDependencies.txt"), preReleaseDependencies.Distinct());

Microsoft.DotNet.PackageTesting (3)

GetCompatiblePackageTargetFrameworks.cs (1)

81return frameworksToTest.Where(tfm => allTargetFrameworks.Contains(tfm)).Distinct();

Package.cs (2)

33FrameworksInPackageList.AddRange(RuntimeAssets.Select(t => (NuGetFramework)t.Properties["tfm"]).Distinct()); 35FrameworksInPackage = FrameworksInPackageList.Distinct();

Microsoft.DotNet.RemoteExecutor (1)

RemoteExecutor.cs (1)

647.Distinct();

Microsoft.DotNet.SourceBuild.Tasks (9)

src\UsageReport\ValidateUsageAgainstBaseline.cs (3)

80used.Usages.Select(u => u.GetIdentityWithoutRid()).Distinct(), 81baseline.Usages.Select(u => u.GetIdentityWithoutRid()).Distinct()); 128used.Usages = used.Usages.Distinct().ToArray();

src\UsageReport\WritePackageUsageData.cs (6)

104.Distinct() 111.Distinct() 116.Distinct() 121.Distinct() 126.Distinct() 195.Distinct(),

Microsoft.DotNet.VersionTools (1)

Automation\DependencyUpdateUtils.cs (1)

31.Distinct()

Microsoft.DotNet.VersionTools.Tasks (1)

UpdateToRemoteDependencies.cs (1)

75.Distinct()

Microsoft.Extensions.DependencyModel (1)

DependencyContextWriter.cs (1)

151foreach (string packageName in runtimeLookup.Keys.Concat(compileLookup.Keys).Distinct())

Microsoft.Extensions.Http.Resilience.Tests (3)

Hedging\HedgingTests.cs (3)

178Assert.Equal(2, Requests.Distinct().Count()); 226RequestContexts.Distinct().OfType<ResilienceContext>().Should().HaveCount(3); 252RequestContexts.Distinct().OfType<ResilienceContext>().Should().HaveCount(3);

Microsoft.Extensions.Identity.Core (3)

PasswordValidator.cs (1)

71if (options.RequiredUniqueChars >= 1 && password.Distinct().Count() < options.RequiredUniqueChars)

UserManager.cs (2)

1131foreach (var role in roles.Distinct()) 2011await store.ReplaceCodesAsync(user, newCodes.Distinct(), CancellationToken).ConfigureAwait(false);

Microsoft.Gen.ComplianceReports (1)