Contains

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

184_indentationMap.Contains(intervalTreeSpan)) 309if (!option.IsMaskOn(SuppressOption.NoSpacing) || _suppressSpacingMap.Contains(operation.TextSpan)) 336if (!option.IsOn(SuppressOption.DisableFormatting) || _suppressFormattingMap.Contains(operation.TextSpan)) 356if (!option.IsMaskOn(SuppressOption.NoWrapping) || _suppressWrappingMap.Contains(operation.TextSpan)) 380_anchorMap.Contains(operation.TextSpan) ||

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

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

212TryAddToWorker(declarations, checkGeneratedCode, out declaration, out availableIndices, d => ancestors.Contains(d)) ||

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

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (2)

32while (nameSet.Contains(result)) 123while (usedNames.Contains(updatedName) || !canUse(updatedName))

illink (23)

Linker.Dataflow\MethodBodyScanner.cs (1)

177if (_foundEndOfPrevBlock || _methodBranchTargets.Contains(op.Offset))

Linker.Steps\SealerStep.cs (1)

63return bt != null && referencedBaseTypeCache.Contains(bt);

Linker.Steps\ValidateVirtualMethodAnnotationsStep.cs (1)

35if (annotations.VirtualMethodsWithAnnotationsToValidate.Contains(overrideInformation.Override))

Linker\Annotations.cs (13)

157if (!processed.Contains(provider)) 164if (!processed.Contains(provider)) 189return processed.Contains(provider) || marked_pending.ContainsKey(provider); 194return marked_attributes.Contains(attribute); 212return indirectly_called.Contains(method); 222return reflection_used.Contains(method); 232return marked_instantiated.Contains(type); 243return types_relevant_to_variant_casting.Contains(type); 260return processed.Contains(provider); 286Debug.Assert(!pending_preserve.Contains(type)); 392return assemblies_with_root_all_members.Contains(assembly); 428return public_api.Contains(provider); 559return marked_types_with_cctor.Contains(type);

Linker\AssemblyResolver.cs (1)

111if (unresolvedAssemblies.Contains(name.Name))

Linker\DependencyRecorderHelper.cs (1)

59if (context.TraceAssembly != null && !context.TraceAssembly.Contains(assembly.Name.Name))

Linker\LinkContext.cs (1)

760if (NoWarn.Contains(warningCode))

Linker\TypeMapHandler.cs (1)

131if (referenceTypeMapGroups.Contains(typeMapGroup))

src\tools\illink\src\ILLink.Shared\DataFlow\ValueSet.cs (3)

54if (!other.Contains(item)) 58if (!Contains(item)) 239return valuesSet.Contains(value);

ILLink.RoslynAnalyzer (5)

DataFlow\LValueFlowCaptureProvider.cs (2)

68var captureKind = assignment?.IsAnyCompoundAssignment() == true || rvalueFlowCaptureIds.Contains(flowCaptureReference.Id) 86Debug.Assert(kind == FlowCaptureKind.LValueAndRValueCapture || !rvalueFlowCaptureIds.Contains(captureId), "Flow capture used as both an r-value and an l-value, but with incorrect flow capture kind");

src\tools\illink\src\ILLink.Shared\DataFlow\ValueSet.cs (3)

54if (!other.Contains(item)) 58if (!Contains(item)) 239return valuesSet.Contains(value);

ILLink.Tasks (2)

CreateRuntimeRootDescriptorFile.cs (1)

608if (defineConstants.Contains(defineName))

LinkTask.cs (1)

430if (assemblyNames.Contains(assemblyName))

Infrastructure.Common (1)

xunit\IssueAttribute.cs (1)

151return s_includeIssuesHash.Contains(issue);

installer.tasks (2)

FileUtilities.cs (1)

32if (!s_assemblyExtensions.Contains(Path.GetExtension(path)))

GenerateTestSharedFrameworkDepsFile.cs (1)

54.Where(file => !ignoredExtensions.Contains(Path.GetExtension(file)))

IOperationGenerator (2)

IOperationClassWriter.cs (2)

497if (newProps.Contains(prop.Name)) 964if (prop.MakeAbstract || newProps.Contains(prop.Name))

KeyManagementSimulator (1)

Program.cs (1)

431if (!_knownKeyIds.Contains(defaultKeyId) && !_missingSinceMap.ContainsKey(defaultKeyId))

Metrics (21)

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

Metrics.Legacy (21)

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

Microsoft.Analyzers.Extra (4)

AsyncMethodWithoutCancellation.cs (1)

158if (typeSymbols.Contains(argument.Type))

CallAnalysis\CallAnalyzer.Handlers.cs (1)

39if (_state.InterfaceMethodNames.Contains(target.Name))

MakeExeTypesInternalAnalyzer.cs (2)

101if (disqualifyingTypeAttributes.Contains(attr.AttributeClass)) 126if (disqualifyingMemberAttributes.Contains(attr.AttributeClass))

Microsoft.Analyzers.Local (3)

ApiLifecycle\AssemblyAnalysis.cs (2)

163if (!baseTypes.Contains(@base)) 179if (!constraints.Contains(constraint))

CallAnalysis\CallAnalyzer.Handlers.cs (1)

39if (_state.InterfaceMethodNames.Contains(target.Name))

Microsoft.Arcade.Test.Common (2)

MockFileSystem.cs (2)

40public bool DirectoryExists(string path) => Directories.Contains(path); 73if (Directories.Contains(path))

Microsoft.AspNetCore.App.UnitTests (7)

SharedFxTests.cs (3)

185var expectedVersion = repoAssemblies.Contains(name) ? aspnetcoreVersion : version; 193if (repoAssemblies.Contains(name)) 229if (!repoAssemblies.Contains(Path.GetFileNameWithoutExtension(path)))

TargetingPackTests.cs (4)

78var expectedVersion = repoAssemblies.Contains(Path.GetFileNameWithoutExtension(path)) ? 90if (repoAssemblies.Contains(Path.GetFileNameWithoutExtension(path))) 177if (runtimeDependencies.Contains(packageName)) 181else if (packageName.Equals("Microsoft.AspNetCore.App", StringComparison.Ordinal) || aspnetcoreDependencies.Contains(packageName))

Microsoft.AspNetCore.Authentication.Core (1)

AuthenticationService.cs (1)

85if (_transformCache.Contains(principal))

Microsoft.AspNetCore.Authentication.Negotiate (1)

Internal\LdapAdapter.cs (1)

129if (processedGroups.Contains(nestedGroupDN))

Microsoft.AspNetCore.Components (2)

Routing\RouteTableFactory.cs (1)

240if (!routeParameterNames.Contains(item))

src\Http\Routing\src\RouteConstraintBuilder.cs (1)

67if (_optionalParameters.Contains(kvp.Key))

Microsoft.AspNetCore.Components.Endpoints (3)

Discovery\ComponentApplicationBuilder.cs (2)

39return _assemblies.Contains(assemblyName); 75if (_assemblies.Contains(libraryBuilder.AssemblyName))

Rendering\EndpointHtmlRenderer.Streaming.cs (1)

157if (_visitedComponentIdsInCurrentStreamingBatch.Contains(componentId))

Microsoft.AspNetCore.Components.Server (2)

Circuits\ServerComponentDeserializer.cs (2)

167if (_expiredInvocationIds.Contains(serverComponent.InvocationId)) 184if (_seenSequenceNumbersForCurrentInvocation.Contains(serverComponent.Sequence))

Microsoft.AspNetCore.Components.Web (1)

HtmlRendering\StaticHtmlRenderer.HtmlWriting.cs (1)

167if (SelfClosingElements.Contains(frame.ElementName))

Microsoft.AspNetCore.Components.WebView (1)

src\Shared\StaticWebAssets\ManifestStaticWebAssetFileProvider.cs (1)

103if (!files.Contains(result))

Microsoft.AspNetCore.DataProtection (2)

KeyManagement\XmlKeyManager.cs (2)

471if (deletedKeyIds.Contains(revocationId) || !allKeyIds.Contains(revocationId))

Microsoft.AspNetCore.DataProtection.Tests (6)

Repositories\EphemeralXmlRepositoryTests.cs (2)

82Assert.Equal(!delete1, elementSet.Contains(element1.Name.LocalName)); 83Assert.Equal(!delete2, elementSet.Contains(element2.Name.LocalName));

Repositories\FileSystemXmlRepositoryTests.cs (2)

187Assert.Equal(!delete1, elementSet.Contains(element1.Name.LocalName)); 188Assert.Equal(!delete2, elementSet.Contains(element2.Name.LocalName));

Repositories\RegistryXmlRepositoryTests.cs (2)

175Assert.Equal(!delete1, elementSet.Contains(element1.Name.LocalName)); 176Assert.Equal(!delete2, elementSet.Contains(element2.Name.LocalName));

Microsoft.AspNetCore.DeveloperCertificates.XPlat (2)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

Microsoft.AspNetCore.Grpc.JsonTranscoding (2)

Internal\JsonTranscodingServerCallContext.cs (1)

151if (header.Key.StartsWith(':') || GrpcProtocolConstants.FilteredHeaders.Contains(header.Key))

src\Grpc\JsonTranscoding\src\Shared\ServiceDescriptorHelpers.cs (1)

50WellKnownTypeNames.Contains(messageDescriptor.File.Name);

Microsoft.AspNetCore.Grpc.Swagger (1)

src\Grpc\JsonTranscoding\src\Shared\ServiceDescriptorHelpers.cs (1)

50WellKnownTypeNames.Contains(messageDescriptor.File.Name);

Microsoft.AspNetCore.Hosting (1)

src\Shared\StaticWebAssets\ManifestStaticWebAssetFileProvider.cs (1)

103if (!files.Contains(result))

Microsoft.AspNetCore.HttpLogging (1)

HttpLoggingMiddleware.cs (1)

356if (!allowedHeaders.Contains(key))

Microsoft.AspNetCore.InternalTesting (1)

Tracing\CollectingEventListener.cs (1)

50if (_requestedEventSources.Contains(eventSource.Name))

Microsoft.AspNetCore.Mvc.Api.Analyzers (1)

AddResponseTypeAttributeCodeFixAction.cs (1)

118if (!declaredUsings.Contains(@namespace))

Microsoft.AspNetCore.Mvc.Core (2)

ModelBinding\FormValueProvider.cs (1)

101var culture = _invariantValueKeys?.Contains(key) == true ? CultureInfo.InvariantCulture : Culture;

ModelBinding\JQueryFormValueProvider.cs (1)

41if (result.Length > 0 && _invariantValueKeys?.Contains(key) == true)

Microsoft.AspNetCore.Mvc.Core.Test (1)

ModelBinding\Validation\ValidationStackTest.cs (1)

111return HashSet.Contains(model);

Microsoft.AspNetCore.Mvc.Razor (1)

RazorPage.cs (1)

155if (_renderedSections.Contains(sectionName))

Microsoft.AspNetCore.Mvc.ViewFeatures (5)

Rendering\MultiSelectList.cs (2)

169Selected = selectedValues.Contains(value), 193Selected = selectedValues.Contains(item),

TempDataDictionary.cs (2)

169if (!_initialKeys.Contains(entry.Key) && !_retainedKeys.Contains(entry.Key))

TemplateInfo.cs (1)

117return _visitedObjects.Contains(modelExplorer.Model ?? modelExplorer.Metadata.ModelType);

Microsoft.AspNetCore.Owin (4)

OwinEnvironment.cs (4)

520if (_deletedKeys?.Contains(key) == true) 541if (_deletedKeys?.Contains(key) == true) 578if (_deletedKeys?.Contains(entry.Key) == true) 588if (_deletedKeys?.Contains(entry.Key) == true)

Microsoft.AspNetCore.ResponseCompression (3)

ResponseCompressionProvider.cs (3)

206?? _mimeTypes.Contains("*/*"); //check wildcard */* 234if (_excludedMimeTypes.Contains(mimeType)) 239if (_mimeTypes.Contains(mimeType))

Microsoft.AspNetCore.Routing (2)

DecisionTree\DecisionTreeBuilder.cs (1)

119if (context.CurrentCriteria.Contains(kvp.Key))

RouteConstraintBuilder.cs (1)

67if (_optionalParameters.Contains(kvp.Key))

Microsoft.AspNetCore.Server.HttpSys (1)

src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (1)

289if (_checkTrailers && DisallowedTrailers.Contains(key))

Microsoft.AspNetCore.Server.IIS (1)

src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (1)

289if (_checkTrailers && DisallowedTrailers.Contains(key))

Microsoft.AspNetCore.Server.Kestrel.Core (2)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

Microsoft.AspNetCore.Shared.Tests (1)

src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (1)

289if (_checkTrailers && DisallowedTrailers.Contains(key))

Microsoft.AspNetCore.SpaServices.Extensions (3)

Proxying\SpaProxy.cs (3)

147if (NotForwardedHttpHeaders.Contains(header.Key)) 171&& InvalidH2H3Headers.Contains(header.Key)) 222if (!NotForwardedWebSocketHeaders.Contains(headerEntry.Key))

Microsoft.Build.Framework (1)

BinaryTranslator.cs (1)

620if (additionalEntriesKeys.Contains(key))

Microsoft.Cci.Extensions (19)

Extensions\CSharp\CSharpCciExtensions.cs (2)

163if (!visited.Contains(field.Type)) 204if (!visited.Contains(field.Type))

Filters\DocIdExcludeListFilter.cs (7)

42return !_docIds.Contains(namespaceId); 50return !_docIds.Contains(typeId); 70return !_docIds.Contains(memberId); 77if (genericType != null && genericType.GenericArguments.Any(genArg => _docIds.Contains(genArg.DocId()))) 82return !_docIds.Contains(typeId); 93if (_docIds.Contains(removeUsages)) 112return !_docIds.Contains(typeId);

Filters\DocIdIncludeListFilter.cs (5)

38return _docIds.Contains(namespaceId); 47return _docIds.Contains(typeId); 53return _docIds.Contains(memberId); 61if (_docIds.Contains(removeUsages)) 64return _docIds.Contains(typeId);

Filters\ExcludeAttributesFilter.cs (1)

31return !_attributeDocIds.Contains(attribute.DocId());

HostEnvironment.cs (2)

258.FirstOrDefault(ai => !consideredIdentities.Contains(ai)); 262if (coreIdentity == null || consideredIdentities.Contains(coreIdentity))

Traversers\AssemblyReferenceTraverser.cs (2)

49if (!UsedAssemblyReferences.Contains(id)) // Only checking for contains for so can easily see new additions with a breakpoint in the debugger. 63if (!AliasedAssemblyReferences.Contains(id))

Microsoft.CodeAnalysis (28)

Collections\IdentifierCollection.cs (1)

127return set.Contains(identifier);

Collections\OrderedSet.cs (1)

65return _set.Contains(item);

CommandLine\CommonCompiler.cs (2)

323if (processedDirs.Contains(directory)) 539if (_reportedDiagnostics.Contains(diag))

CommandLine\CommonCompiler.ExistingReferencesResolver.cs (1)

47return resolvedReferences.WhereAsArray(r => _lazyAvailableReferences.Value.Contains(TryGetIdentity(r)!));

CommandLine\SarifV2ErrorLogger.cs (1)

273var hasAnySourceSuppression = _diagnosticIdsWithAnySourceSuppressions.Contains(descriptor.Id);

Compilation\Compilation.cs (1)

1889if (exclude?.Contains(d.Code) == true)

DiagnosticAnalyzer\AnalysisResultBuilder.cs (4)

176if (!arg.self._completedAnalyzersForCompilation.Contains(analyzer) && 177(arg.completedAnalyzersForFile == null || !arg.completedAnalyzersForFile.Contains(analyzer))) 199if (_completedAnalyzersForCompilation.Contains(analyzer)) 219if (completedAnalyzersForFile?.Contains(analyzer) == true)

DiagnosticAnalyzer\AnalyzerDriver.cs (4)

1856if (!processedAnalyzers.Contains(analyzer)) 2087if (symbolStartAnalyzers.Contains(analyzer)) 2631if (!analyzersForNodes.Contains(analyzer) || !analysisScope.Contains(analyzer)) 2904bool shouldAddNode(SyntaxNode node) => (descendantDeclsToSkip == null || !descendantDeclsToSkip.Contains(node)) && (additionalFilter is null || additionalFilter(node));

Emit\CommonPEModuleBuilder.cs (1)

714return _namesOfTopLevelTypes.Contains(fullEmittedName);

Emit\EditAndContinue\DefinitionMap.cs (1)

733if (lambdaIdSet.Contains(entry.id))

Emit\NoPia\EmbeddedTypesManager.cs (1)

140if (namesOfTopLevelTypes.Contains(MetadataHelpers.BuildQualifiedName(def.NamespaceName, def.Name)))

InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

NativePdbWriter\PdbWriter.cs (1)

438if (assembly == alias.Assembly && declaredExternAliases.Contains(alias.Name))

Operations\ControlFlowGraphBuilder.cs (2)

1224if (branch.Destination != null && unresolved.Contains(branch.Destination)) 1896if (candidate.HasCaptureIds && candidate.CaptureIds.Any((id, set) => set.Contains(id), idsStillOnTheStack))

RuleSet\RuleSet.cs (1)

133if (includedRulesetPaths.Contains(ruleSet.FilePath.ToLowerInvariant()))

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

Syntax\SyntaxDiffer.cs (4)

458if (_nodeSimilaritySet.Contains(tr.UnderlyingNode)) 467if (_nodeSimilaritySet.Contains(tr.UnderlyingNode)) 489if (_nodeSimilaritySet.Contains(n2.UnderlyingNode)) 496if (_tokenTextSimilaritySet.Contains(tokenText))

Microsoft.CodeAnalysis.Analyzers (29)

MetaAnalyzers\DiagnosticAnalyzerAPIUsageAnalyzer.cs (1)

147if (!processedTypes.Contains(usedType) && namedTypesToAccessedTypesMap.ContainsKey(usedType))

MetaAnalyzers\RegisterActionAnalyzer.cs (2)

477if (_startAnalysisContextParamsToSkip != null && _startAnalysisContextParamsToSkip.Contains(contextParameter)) 503if (_startAnalysisContextParamsToSkip != null && _startAnalysisContextParamsToSkip.Contains(contextParameter))

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

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

212TryAddToWorker(declarations, checkGeneratedCode, out declaration, out availableIndices, d => ancestors.Contains(d)) ||

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

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (2)

32while (nameSet.Contains(result)) 123while (usedNames.Contains(updatedName) || !canUse(updatedName))

Microsoft.CodeAnalysis.AnalyzerUtilities (31)

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\RoslynAnalyzers\Utilities\FlowAnalysis\Extensions\BasicBlockExtensions.cs (1)

227if (!processedOrdinals.Contains(destinationBlock.Ordinal))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\GlobalFlowStateAnalysis\GlobalFlowStateAnalysis.GlobalFlowStateAnalysisValueSetDomain.cs (1)

174if (candidateNodes.Contains(parent))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\TrackedEntitiesBuilder.cs (1)

63=> PointsToValues.Contains(value);

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

137if (!allEntities.Contains(analysisEntity)) 607if (analysisEntity != null && candidateEntitiesBuilder.Contains(analysisEntity))

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

255var isUnreachableBlock = unreachableBlocks.Contains(block.Ordinal); 368if (isUnreachableBlock && !unreachableBlocks.Contains(successorBlock.Ordinal))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (3)

643Debug.Assert(_visitedLambdas.Contains(lambda)); 2333Debug.Assert(arguments.All(arg => !_pendingArgumentsToReset.Contains(arg))); 2395Debug.Assert(arguments.All(_pendingArgumentsToReset.Contains));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

Microsoft.CodeAnalysis.BannedApiAnalyzers (26)

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

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

212TryAddToWorker(declarations, checkGeneratedCode, out declaration, out availableIndices, d => ancestors.Contains(d)) ||

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

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (2)

32while (nameSet.Contains(result)) 123while (usedNames.Contains(updatedName) || !canUse(updatedName))

Microsoft.CodeAnalysis.CodeStyle (26)

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

574var rule = !valueUsageInfo.IsWrittenTo() && !valueUsageInfo.IsNameOnly() && !symbolsReferencedInDocComments.Contains(member) 603!_propertiesWithShadowGetAccessorUsages.Contains(property);

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

233if (!fieldNames.Contains(identifier.ValueText)) 511if (!fieldNames.Contains(syntaxFacts.GetIdentifierOfIdentifierName(identifierName).ValueText)) 616if (reportedFields.Contains(result.Field) || reportedProperties.Contains(result.Property))

src\Analyzers\Core\Analyzers\UseConditionalExpression\ForAssignment\UseConditionalExpressionForAssignmentHelpers.cs (1)

148declaredPatternSymbols.Contains(local))

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

Microsoft.CodeAnalysis.CodeStyle.Fixes (16)

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

452if (!methodParameterNames.Contains(argumentName))

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

185if (alreadyCheckingTypes.Contains(constraint)) 206if (alreadyCheckingTypes.Contains(genericParam))

src\Analyzers\Core\CodeFixes\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (3)

97if (declarators.Contains(parentDeclaration)) 99Debug.Assert(childDeclarators.All(c => !declarators.Contains(c))); 106if (!declarators.Contains(childDeclarator))

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

649if (!processedNodes.Contains(node)) 654if (containingDeclaration != null && candidateDeclarationStatementsForRemoval.Contains(containingDeclaration)) 707if (nodesToRemove.Contains(insertionNode) && !processedNodes.Contains(insertionNode)) 732if (!nodesToRemove.Contains(variable))

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

212TryAddToWorker(declarations, checkGeneratedCode, out declaration, out availableIndices, d => ancestors.Contains(d)) ||

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

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (2)

32while (nameSet.Contains(result)) 123while (usedNames.Contains(updatedName) || !canUse(updatedName))

Microsoft.CodeAnalysis.Collections.Package (1)

Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

Microsoft.CodeAnalysis.CSharp (80)

Binder\Binder_Attributes.cs (1)

498else if (boundNamedArgumentsSet!.Contains(argumentName))

Binder\Binder_Expressions.cs (1)

1192if (inferredName != null && toRemove.Contains(inferredName))

Binder\Binder_Lookup.cs (1)

1037if (!conflictingMembers.Contains(sym))

Binder\Binder_Operators.cs (2)

3649if (IsViableInstanceOperator(method, parameterCount) && !existing.Contains(method.GetLeastOverriddenMethod(ContainingType))) 3711if (!existing.Contains(method))

Binder\DecisionDagBuilder.cs (1)

246if (usedValues.Contains(e))

Binder\Imports.cs (1)

206return externs1.WhereAsArray((e, replacedExternAliases) => !replacedExternAliases.Contains(e.Alias.Name), replacedExternAliases).AddRange(externs2);

Binder\RefSafetyAnalysis.cs (1)

299RoslynDebug.Assert(_visited.Contains(expr), $"Expected {expr} `{expr.Syntax}` to be visited.");

Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (2)

277if (shadowedInterfaces.Contains(@interface)) 1480if (!existing.Contains(op.Method))

Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (2)

129if (!existing.Contains(op.Method)) 698if (shadowedInterfaces.Contains(@interface))

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

531if (hiddenSymbols.Contains(result.Member.ConstructedFrom()))

BoundTree\BoundNode.cs (1)

524if (!DeclaredLocals.Contains(local))

CodeGen\CodeGenerator.cs (1)

203=> stackLocalsOpt?.Contains(local) ?? false;

Compilation\CSharpCompilation.cs (3)

877if (externalSyntaxTrees.Contains(tree)) 941if (!externalSyntaxTrees.Contains(tree)) 3661if (_duplicatePaths.Contains(filePath!))

Compilation\CSharpSemanticModel.cs (2)

4157if (hiddenSymbols == null || !hiddenSymbols.Contains(indexer.GetSymbol())) 4234return methods.WhereAsArray((m, hiddenSymbols) => !hiddenSymbols.Contains(m), hiddenSymbols);

Compilation\SyntaxAndDeclarationManager.cs (2)

307var newExternalSyntaxTrees = this.ExternalSyntaxTrees.RemoveAll(t => trees.Contains(t)); 340if (removeSet.Contains(tree))

Compiler\DocumentationCommentCompiler.cs (2)

418if (!documentedParameters.Contains(parameter)) 433if (!documentedTypeParameters.Contains(typeParameter))

Emitter\Model\PEModuleBuilder.cs (1)

273if (debugDocument is not null && !methodDocumentList.Contains(debugDocument))

FlowAnalysis\AlwaysAssignedWalker.cs (1)

137if (branch.Branch != null && RegionContains(branch.Branch.Syntax.Span) && !_labelsInside.Contains(branch.Label))

FlowAnalysis\ControlFlowPass.cs (1)

140if (!_labelsUsed.Contains(label))

FlowAnalysis\DataFlowsOutWalker.cs (1)

266if (!_dataFlowsOut.Contains(parameter) && (node == null || node is ReturnStatementSyntax))

FlowAnalysis\DefiniteAssignment.cs (10)

598if (diagnostic.Severity != DiagnosticSeverity.Error || compatDiagnosticSet.Contains(diagnostic)) 1894if (slot > 0) SetSlotState(slot, initiallyAssignedVariables?.Contains(parameter) == true); 1960if (_readParameters?.Contains(parameter) != true && 2278Debug.Assert(_usedVariables.Contains(local)); 2322initiallyAssignedVariables?.Contains(symbol) == true; 2336if (!_usedVariables.Contains(symbol)) 2340Diagnostics.Add(assigned && _writtenVariables.Contains(symbol) ? ErrorCode.WRN_UnreferencedVarAssg : ErrorCode.WRN_UnreferencedVar, symbol.GetFirstLocationOrNone(), symbol.Name); 2386_capturedVariables.Contains(localSymbol)) 2398if (initiallyAssignedVariables?.Contains(node.LocalSymbol) == true) 2563if (_unassignedVariableAddressOfSyntaxes?.Contains(node.Syntax as PrefixUnaryExpressionSyntax) == false)

FlowAnalysis\NullableWalker.DebugVerifier.cs (1)

48if (!verifier._visitedExpressions.Contains(analyzedNode))

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (2)

785return _awaitContainingCatches != null && _awaitContainingCatches.Contains(node); 959if (this.IsRoot() || (LabelsOpt != null && LabelsOpt.Contains(label)))

Lowering\ClosureConversion\ClosureConversion.Analysis.cs (1)

41&& !MethodsConvertedToDelegates.Contains(function);

Lowering\ClosureConversion\ClosureConversion.Analysis.Tree.cs (1)

671Debug.Assert(_freeVariables.Contains(symbol));

Lowering\ClosureConversion\ClosureConversion.cs (2)

441_analysis.MethodsConvertedToDelegates.Contains(originalMethod)) || 770if (_assignLocals == null || !_assignLocals.Contains(local))

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.IteratorFinallyFrame.cs (1)

101if (this.IsRoot() || (labels != null && labels.Contains(label)))

Lowering\LocalRewriter\DelegateCacheRewriter.cs (1)

211if (used.Contains(typeParameter))

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.cs (7)

394bool alreadyLowered = loweredNodes.Contains(node); 419if (nextNode != null && loweredNodes.Contains(nextNode)) 461!loweredNodes.Contains(nodesToLower[indexOfNode + 2]) ? nodesToLower[indexOfNode + 2] : null; 500Debug.Assert(!loweredNodes.Contains(node)); 528Debug.Assert(!loweredNodes.Contains(test2)); 564if (loweredNodes.Contains(node)) 596!loweredNodes.Contains(p))

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (1)

426if ((object)s != null && !_localsInScope.Contains(s))

Lowering\SyntheticBoundNodeFactory.cs (1)

1127Debug.Assert(!labels.Contains(v2));

Symbols\BaseTypeAnalysis.cs (3)

27var result = hs.Contains(on); 73var result = typesWithCycle.Contains(on); 84if (typesWithCycle.Contains(type.OriginalDefinition))

Symbols\Compilation_UsedAssemblies.cs (1)

54if (setOfReferences.Contains(reference))

Symbols\MemberSignatureComparer.cs (1)

731if (constraintTypes2.Contains(constraintType))

Symbols\OverriddenOrHiddenMembersHelpers.cs (2)

423if (allMembersHidden.Contains(currType)) 461if (!membersOfOtherKindsHidden.Contains(currType))

Symbols\Source\ConstantEvaluationHelpers.cs (1)

76Debug.Assert(fields.All(f => map.Contains(f)));

Symbols\Source\ParameterHelpers.cs (1)

569if (!usedTypeParameters.Contains(typeParameter))

Symbols\Source\SourceAssemblySymbol.cs (3)

1256if (!uniqueAttributes.Contains(attribute)) 1767if (!t_forwardedTypesAttributesInProgress.Contains(node)) 2756if (handledUnreadFields != null && handledUnreadFields.Contains(field))

Symbols\Source\SourceMemberContainerSymbol.cs (2)

2278if (typeParameterNames.Contains(indexerName)) 5218if (memberNames.Contains(symbol.Name) || this.GetTypeMembersDictionary().ContainsKey(symbol.Name.AsMemory()))

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

779diagnostics.Add(!globalUsingNamespacesOrTypes.IsEmpty && getOrCreateUniqueGlobalUsingsNotInTree(ref uniqueGlobalUsings, globalUsingNamespacesOrTypes, declarationSyntax.SyntaxTree).Contains(imported) ? 805diagnostics.Add(!globalUsingNamespacesOrTypes.IsEmpty && getOrCreateUniqueGlobalUsingsNotInTree(ref uniqueGlobalUsings, globalUsingNamespacesOrTypes, declarationSyntax.SyntaxTree).Contains(imported) ?

Symbols\SubstitutedNamedTypeSymbol.cs (1)

281if (!replacedFields.Contains(existingMember))

Symbols\Symbol_Attributes.cs (1)

516if (!toRemove.Contains(d))

Symbols\Synthesized\SynthesizedBackingFieldSymbol.cs (1)

205if (!notAnnotatedDiagnosticsSet.Contains(diagnostic))

Symbols\TypeSymbolExtensions.cs (1)

1226(type, parameters, unused) => type.TypeKind == TypeKind.TypeParameter && parameters.Contains((TypeParameterSymbol)type);

Syntax\SyntaxNodeRemover.cs (1)

156return _nodesToRemove.Contains(node);

Utilities\FirstAmongEqualsSet.cs (1)

90if (!_hashSet.Contains(key))

Utilities\TypeSymbolExtensions.cs (2)

213Debug.Assert(visited == null || !visited.Contains(type.OriginalDefinition)); 246if (visited.Contains(nextType.OriginalDefinition))

Microsoft.CodeAnalysis.CSharp.CodeStyle (1)

src\Analyzers\CSharp\Analyzers\UseAutoProperty\CSharpUseAutoPropertyAnalyzer.cs (1)

91return rightmostName != null && fieldNames.Contains(rightmostName);

Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (4)

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateParameterizedMemberService.cs (1)

91s => !usedIdentifiers.Contains(s) && !State.TypeToGenerateIn.GetAllTypeParameters().Any(static (t, s) => t.Name == s, s),

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (2)

129if (declarationsToRemove.Contains(statementSyntax)) 162if (!declarationsToRemove.Contains(statement))

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

214if (!existingParamNodeNames.Contains(parameterName))

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

CodeActions\SyncNamespace\CSharpSyncNamespaceTestsBase.cs (1)

91Assert.True(actualFolderPaths.Contains(expected));

Completion\CompletionProviders\TypeImportCompletionProviderTests.cs (1)

1486var actualTypesInRelativeOrder = allCompletionItems.SelectAsArray(item => hashset.Contains(item.DisplayText), item => item.DisplayText);

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

Diagnostics\GetDiagnosticsTests.cs (13)

Microsoft.CodeAnalysis.CSharp.Features (16)

Completion\CompletionProviders\DeclarationName\DeclarationNameRecommender.cs (2)

105if (seenTypes.Contains(type)) 150if (seenTypes.Contains(collectionType))

Completion\CompletionProviders\PropertySubPatternCompletionProvider.cs (1)

79members = members.WhereAsArray(m => !alreadyTestedMembers.Contains(m.Name));

Completion\CompletionProviders\SnippetCompletionProvider.cs (1)

177snippets = snippets.Where(snippet => !s_snippetsWithReplacements.Contains(snippet.Shortcut));

ConvertLinq\ConvertForEachToLinqQuery\DefaultConverter.cs (1)

31.Where(identifier => variableNamesReadInside.Contains(identifier.ValueText));

ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (2)

662queryExpressionProcessingInfo.IdentifierNames.Contains(identifierName.Identifier.ValueText)) 980=> IdentifierNames.Contains(identifier.ValueText);

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (1)

376if (identifierName.GetAncestors<EqualsValueClauseSyntax>().Any(removedInitializers.Contains))

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs (1)

225=> _aliasedNames.Contains(identifier);

InlineHints\CSharpInlineParameterNameHintsService.cs (1)

79if (presentNames.Contains(parameter?.Name))

IntroduceVariable\CSharpIntroduceVariableService_IntroduceQueryLocal.cs (1)

62var firstClauseAffectedInQuery = oldClauses.First(allAffectedClauses.Contains);

src\Analyzers\CSharp\Analyzers\UseAutoProperty\CSharpUseAutoPropertyAnalyzer.cs (1)

91return rightmostName != null && fieldNames.Contains(rightmostName);

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateParameterizedMemberService.cs (1)

91s => !usedIdentifiers.Contains(s) && !State.TypeToGenerateIn.GetAllTypeParameters().Any(static (t, s) => t.Name == s, s),

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (2)

129if (declarationsToRemove.Contains(statementSyntax)) 162if (!declarationsToRemove.Contains(statement))

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

214if (!existingParamNodeNames.Contains(parameterName))

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

Diagnostics\Suppression\RemoveUnnecessaryPragmaSuppressionsTests.cs (1)

93if (usedLocals.Contains(local))

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

Symbols\CorLibrary\CorTypes.cs (2)

69if (knownMissingTypes.Contains(i)) 86if (knownMissingTypes.Contains(i))

Symbols\Metadata\MetadataMemberTests.cs (4)

626Assert.True(memberNames1.Contains(m), m); 636Assert.True(memberNames2.Contains(m), m); 667Assert.True(memberNames1.Contains(m), m); 678Assert.True(memberNames2.Contains(m), m);

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

IncrementalParsing\SyntaxDifferences.cs (1)

35if (hashSet.Contains(newNode.UnderlyingNode))

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

TestAttributesVisitor.cs (1)

128if (_reported.Contains(s))

Microsoft.CodeAnalysis.CSharp.Workspaces (4)

FindSymbols\CSharpDeclaredSymbolInfoFactoryService.cs (1)

440if (!existingFieldPropNames.Contains(parameter.Identifier.ValueText))

Rename\CSharpRenameRewriterLanguageService.cs (2)

466if (identifierToken != default && !_annotatedIdentifierTokens.Contains(identifierToken)) 504if (_invocationExpressionsNeedingConflictChecks.Contains(node))

Simplification\Reducers\AbstractCSharpReducer.AbstractReductionRewriter.cs (1)

138if (node != newNode || _processedParentNodes.Contains(parentNode))

Microsoft.CodeAnalysis.EditorFeatures (2)

CodeDefinitionWindow\DefinitionContextTracker.cs (1)

79if (!_subscribedViews.Contains(textView) && !textView.Roles.Contains(PredefinedTextViewRoles.CodeDefinitionView))

Editor\TextBufferAssociatedViewService.cs (1)

152Contract.ThrowIfTrue(set.Contains(view));

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

Classification\AbstractClassifierTests.cs (1)

296where !classificationsSpans.Contains(t.TextSpan)

Rename\RenamerTests.cs (1)

80Assert.True(remainingErrors.Contains(error), $"Error '{error}' was unexpected");

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (5)

CodeFixes\CodeFixServiceTests.cs (2)

649Assert.Equal(expectedNuGetFixerCodeActionWasRegistered, fixTitles.Contains(nameof(NuGetCodeFixProvider))); 650Assert.Equal(expectedVsixFixerCodeActionWasRegistered, fixTitles.Contains(nameof(VsixCodeFixProvider)));

Utilities\BloomFilterTests.cs (3)

59var actualContains = strings.Contains(test); 179var actualContains = longs.Contains(test); 245var actualContains = strings.Contains(test);

Microsoft.CodeAnalysis.ExpressionEvaluator.ExpressionCompiler (2)

AbstractTypeParameterChecker.cs (1)

31if (!_acceptableTypeParameters.Contains(symbol))

MetadataUtilities.cs (1)

316if (referencedIndices.Contains(i))

Microsoft.CodeAnalysis.Extensions.Package (1)

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

Microsoft.CodeAnalysis.Features (74)

BraceMatching\AbstractEmbeddedLanguageBraceMatcher.cs (1)

37if (!this.SyntaxTokenKinds.Contains(token.RawKind))

CodeFixes\FixAllOccurrences\AbstractFixAllCodeFixCodeAction.cs (1)

37&& s_predefinedCodeFixProviderNames.Contains(exportAttribute.Name);

CodeFixesAndRefactorings\CodeActionRequestPriorityProvider.cs (2)

144if (_lowPriorityAnalyzerSupportedDiagnosticIds.Contains(diagnosticId)) 156return _lowPriorityAnalyzers != null && _lowPriorityAnalyzers.Contains(analyzer);

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

266.DescendantNodes(spine.Contains)

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (2)

654allNamespaceNameParts.Contains(syntaxFacts.GetIdentifierOfSimpleName(simpleName).ValueText)) 812if (linkedDocumentsToSkip.Contains(id))

Completion\Providers\AbstractDocCommentCompletionProvider.cs (2)

228if (symbol is IPropertySymbol && !existingTopLevelTags.Contains(ValueElementName)) 234if (returns && !existingTopLevelTags.Contains(ReturnsElementName))

Completion\Providers\AbstractObjectInitializerCompletionProvider.cs (1)

52var uninitializedMembers = members.Where(m => !alreadyTypedMembers.Contains(m.Name));

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

144if (namespacesInScope.Contains(containingNamespace))

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

103if (nonGlobalAliasedProjectReferencesSet.Contains(projectId))

DocumentHighlighting\AbstractDocumentHighlightsService.cs (1)

292if (span != null && !spanSet.Contains(span.Value))

EditAndContinue\AbstractEditAndContinueAnalyzer.ActiveMembersBuilder.cs (2)

77if (_methods.Contains(method)) 83return _methods.Contains(method);

EditAndContinue\CommittedSolution.cs (1)

149return _staleProjects.Contains(id);

EditAndContinue\EditSession.cs (1)

1415if (!unremappedActiveMethods.Contains(methodInstance.Method))

EmbeddedLanguages\Classification\AbstractEmbeddedLanguageClassificationService.cs (1)

122if (token.Span.IntersectsWith(_textSpan) && _owner.SyntaxTokenKinds.Contains(token.RawKind))

EmbeddedLanguages\EmbeddedLanguageDetector.cs (2)

42return LanguageIdentifiers.Contains(identifier); 56=> LanguageIdentifiers.Contains(identifier);

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

93if (name != null && _methodNamesOfInterest.Contains(name))

EncapsulateField\AbstractEncapsulateFieldService.cs (1)

289.Filter((documentId, span) => !linkedProjectIds.Contains(documentId.ProjectId) && filter(documentId, span))

Extensions\ExtensionMessageHandlerService.cs (1)

204potentiallyRefersToUnregisteredHandlerName = unregisteredHandlerNames.Contains(messageName);

ExtractMethod\AbstractSyntaxTriviaService.Result.cs (1)

163if (set.Contains(key))

ExtractMethod\MethodExtractor.Analyzer.cs (10)

ExtractMethod\MethodExtractor.CodeGenerator.cs (1)

412if (parameter != null && set.Contains(parameter))

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (2)

125Prioritize(groups, g => g.Any(priorityDocumentKeysSet.Contains)), 142Prioritize(group, priorityDocumentKeysSet.Contains),

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (1)

178if (index.DeclaredSymbolInfoSet.Contains(declaredSymbolInfo))

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (2)

207Prioritize(projects, highPriProjects.Contains), 220Prioritize(project.Documents, highPriDocs.Contains),

NavigateTo\NavigateToSearcher.cs (3)

333if (_activeDocument?.Project != null && projectsSet.Contains(_activeDocument.Project)) 338if (projectsSet.Contains(doc.Project)) 490projectIdSet.Where(id => allProjectIdSet.Contains(id))

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (3)

256var useExtendedTimeout = _sourceLinkEnabledProjects.Contains(projectId); 392Contract.ThrowIfTrue(_openedDocumentIds.Contains(info.DocumentId)); 417if (_openedDocumentIds.Contains(info.DocumentId))

QuickInfo\AbstractEmbeddedLanguageQuickInfoProvider.cs (1)

31if (!_embeddedLanguageProviderFeature.SyntaxTokenKinds.Contains(token.RawKind))

RemoveUnusedVariable\AbstractRemoveUnusedVariableCodeFixProvider.cs (1)

187if (!nodesToRemove.Contains(variable))

Shared\Utilities\ExtractTypeHelpers.cs (2)

152if (!allReferencedTypeParameters.Contains(originalTypeParameter) && 162return potentialTypeParameters.WhereAsArray(allReferencedTypeParameters.Contains);

SignatureHelp\AbstractSignatureHelpProvider.cs (1)

122if (!itemParameterNames.Contains(name))

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

574var rule = !valueUsageInfo.IsWrittenTo() && !valueUsageInfo.IsNameOnly() && !symbolsReferencedInDocComments.Contains(member) 603!_propertiesWithShadowGetAccessorUsages.Contains(property);

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

src\Analyzers\Core\Analyzers\UseConditionalExpression\ForAssignment\UseConditionalExpressionForAssignmentHelpers.cs (1)

148declaredPatternSymbols.Contains(local))

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

452if (!methodParameterNames.Contains(argumentName))

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

185if (alreadyCheckingTypes.Contains(constraint)) 206if (alreadyCheckingTypes.Contains(genericParam))

src\Analyzers\Core\CodeFixes\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (3)

97if (declarators.Contains(parentDeclaration)) 99Debug.Assert(childDeclarators.All(c => !declarators.Contains(c))); 106if (!declarators.Contains(childDeclarator))

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

SymbolSearch\Windows\SymbolSearchUpdateEngine.Update.cs (1)

150if (invalidChars.Contains(c))

UnusedReferences\UnusedReferencesRemover.cs (3)

153if (!projectAssemblyFileNames.Any(static (name, usedProjectFileNames) => usedProjectFileNames.Contains(name), usedProjectFileNames)) 168if (!reference.CompilationAssemblies.Any(static (name, usedAssemblyFilePaths) => usedAssemblyFilePaths.Contains(name), usedAssemblyFilePaths)) 238if (reference.CompilationAssemblies.Any(static (name, usedAssemblyFilePaths) => usedAssemblyFilePaths.Contains(name), usedAssemblyFilePaths))

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (1)

364canEditDocument = document != null && !linkedDocuments.Contains(document.Id);

Microsoft.CodeAnalysis.Features.UnitTests (3)

EditAndContinue\RudeEditDiagnosticTests.cs (3)

83if (arg0.Contains(kind)) 89else if (arg2.Contains(kind)) 97else if (arg3.Contains(kind))

Microsoft.CodeAnalysis.InteractiveHost (1)

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

Microsoft.CodeAnalysis.LanguageServer (1)

LanguageServerExportProviderBuilder.cs (1)

97var hasUnexpectedErroredParts = erroredParts.Any(part => !expectedErrorPartsSet.Contains(part));

Microsoft.CodeAnalysis.LanguageServer.Protocol (2)

Handler\Diagnostics\AbstractPullDiagnosticHandler.cs (2)

197if (!seenDiagnosticSourceIds.Contains(projectOrDocumentId) && 198!removedDocuments.Contains(previousDiagnosticParams))

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (26)

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

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

212TryAddToWorker(declarations, checkGeneratedCode, out declaration, out availableIndices, d => ancestors.Contains(d)) ||

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

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (2)

32while (nameSet.Contains(result)) 123while (usedNames.Contains(updatedName) || !canUse(updatedName))

Microsoft.CodeAnalysis.PublicApiAnalyzers (21)

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

Microsoft.CodeAnalysis.Remote.ServiceHub (7)

Host\AssetProvider.cs (1)

247Contract.ThrowIfTrue(checksums.Contains(Checksum.Null));

Host\RemoteExportProviderBuilder.cs (1)

78var hasUnexpectedErroredParts = erroredParts.Any(part => !expectedErrorPartsSet.Contains(part));

Host\SolutionAssetCache.cs (1)

146if (pinnedChecksums.Contains(checksum))

Host\TestUtils.cs (2)

55var mismatch1 = assetMapFromNewSolution.Where(p => !allChecksumsFromRequest.Contains(p.Key)).ToList(); 59var mismatch2 = assetMapFromIncrementalSolution.Where(p => !allChecksumsFromRequest.Contains(p.Key)).ToList();

Services\DiagnosticAnalyzer\DiagnosticComputer.cs (1)

257shouldInclude = analyzer => analyzersSet.Contains(analyzer);

Services\ProcessTelemetry\RemoteProcessTelemetryService.cs (1)

82bool logChecker(FunctionId id) => functionIdsSet.Contains(id);

Microsoft.CodeAnalysis.Remote.Workspaces (2)

EditAndContinue\ManagedHotReloadLanguageService.cs (1)

293var runningProjectInfos = solution.Projects.Where(p => p.FilePath != null && runningProjectPaths.Contains(p.FilePath)).ToImmutableDictionary(

SolutionAssetStorage.Scope.cs (1)

53Contract.ThrowIfTrue(checksumsToFind.Contains(Checksum.Null));

Microsoft.CodeAnalysis.ResxSourceGenerator (21)

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

Microsoft.CodeAnalysis.ResxSourceGenerator.UnitTests (2)

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

102if (!expectedNames.Contains(name.Substring(currentTestPrefix.Length)))

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

87if (!expectedNames.Contains(name.Substring(currentTestPrefix.Length)))

Microsoft.CodeAnalysis.Scripting (2)

Hosting\AssemblyLoader\MetadataShadowCopyProvider.cs (1)

345if (_lazySuppressedFiles != null && _lazySuppressedFiles.Contains(key.FullPath))

Hosting\ObjectFormatter\CommonObjectFormatter.Visitor.cs (1)

435if (value != null && !VisitedObjects.Contains(value))

Microsoft.CodeAnalysis.Test.Utilities (23)

Assert\AssertXml.cs (1)

183if (!children2Used.Contains(candidate))

CommonTestBase.cs (1)

702Assert.True(set.Contains(operation));

Compilation\ControlFlowGraphVerifier.cs (8)

403AssertTrueWithGraph(currentState.Contains(id), $"Backward branch from [{getBlockId(predecessor.Source)}] to [{getBlockId(block)}] before capture [{id.Value}] is initialized.", finalGraph); 505if (referencedInLastOperation.Contains(id) || 506longLivedIds.Contains(id) || 512(referencedIds.Contains(id) && isAggregateGroupCapture(lastOperation, region, block, id))) 517if (region.LastBlockOrdinal != block.Ordinal && referencedIds.Contains(id)) 763entryState.RemoveWhere(id => !state.Contains(id)); 791AssertTrueWithGraph(state.Contains(id) || isCaptureFromEnclosingGraph(id) || isEmptySwitchExpressionResult(reference), 796if (block.EnclosingRegion.CaptureIds.Contains(id) || longLivedIds.Contains(id))

CompilationVerifier.cs (1)

905if (isManifestModule && fullNameSet.Contains(identity!.GetDisplayName()))

Diagnostics\FieldCouldBeReadOnlyAnalyzer.cs (1)

92if (!field.IsConst && !field.IsReadOnly && !assignedToFields.Contains(field))

Diagnostics\LocalCouldBeConstAnalyzer.cs (1)

86if (!local.IsConst && !assignedToLocals.Contains(local))

Diagnostics\TrackingDiagnosticAnalyzer.cs (1)

139expectedArguments = expectedArguments.Where(a => !symbolKindsWithNoCodeBlocks.Contains(a.SymbolKind));

Metadata\MetadataSignatureUnitTestHelper.cs (2)

150if (!distinctSignatures.Contains(signature)) 161if (!distinctSignatures.Contains(signature))

Mocks\VirtualizedRelativePathResolver.cs (1)

28return _existingFullPaths.Contains(Path.GetFullPath(fullPath));

Platform\Desktop\RuntimeAssemblyManager.cs (3)

140|| _loadedAssemblies.Contains(assembly); 226fullMatch = _preloadedSet.Contains(id.SimpleName) || id.Mvid == assemblyData.Id.Mvid; 239fullMatch = _preloadedSet.Contains(id.SimpleName) || StringComparer.OrdinalIgnoreCase.Equals(id.FullName, assemblyData.Id.FullName);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

TestableFileSystem.cs (1)

60FileExistsFunc = filePath => set.Contains(filePath)

Microsoft.CodeAnalysis.Threading.Package (1)

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

Microsoft.CodeAnalysis.UnitTests (7)

CachingLookupTests.cs (1)

261Assert.False(lookedUp.Contains(s));

Collections\ImmutableSegmentedListBuilderTest.cs (1)

200builder.RemoveAll(elemsToRemove.Contains);

Collections\List\IEnumerable.Generic.Tests.cs (1)

611Assert.True(secondValues.Contains(item));

Collections\List\IEnumerable.NonGeneric.Tests.cs (1)

305Assert.True(secondValues.Contains(item));

Collections\TopologicalSortTests.cs (1)

225Assert.True(seen.Contains(succ), message);

CorLibTypesTests.cs (1)

80if (knownMissingTypes.Contains(specialType))

StrongNameProviderTests.cs (1)

86return fullPath != null && _existingFullPaths != null && _existingFullPaths.Contains(FileUtilities.NormalizeAbsolutePath(fullPath));

Microsoft.CodeAnalysis.VisualBasic (19)

Analysis\FlowAnalysis\DataFlowsOutWalker.vb (3)

57Debug.Assert(Not success OrElse Not result.Any(Function(variable) Not walker._assignedInside.Contains(variable))) 149If Not _dataFlowsOut.Contains(local) AndAlso local.Kind <> SymbolKind.RangeVariable AndAlso Not IsInside Then 192Return Me._originalUnassigned.Contains(sym)

Binding\Binder_Lookup.vb (4)

812If Not conflictingMembers.Contains(sym) Then 1398If verified.Contains(i) Then 1511Debug.Assert(processed.Contains(info)) 1700If processedInterfaces Is Nothing OrElse Not processedInterfaces.Contains(newInfo) Then

Lowering\Diagnostics\DiagnosticsPass_ExpressionLambdas.vb (1)

146If Me._expressionTreePlaceholders.Contains(node) Then

Lowering\LambdaRewriter\LambdaRewriter.vb (5)

244If Not _analysis.variableScope.TryGetValue(captured, node) OrElse _analysis.declaredInsideExpressionLambda.Contains(captured) Then 550If _analysis.needsParentFrame.Contains(node) Then 643If Proxies.TryGetValue(originalSymbol, proxy) AndAlso Not _analysis.declaredInsideExpressionLambda.Contains(originalSymbol) Then 989If _analysis.needsParentFrame.Contains(scope) AndAlso 1360If _analysis.containsLiftingLambda.Contains(curBlock) Then

Symbols\Source\SourceNamedTypeSymbol.vb (3)

894If (constraintType IsNot Nothing) AndAlso Not constraintTypes1.Contains(constraintType) Then 962If Not typeParameterSet.Contains(s.Name) Then 1176If namedType IsNot Nothing AndAlso interfacesInThisPartial.Contains(namedType) Then

Syntax\SyntaxReplacer.vb (3)

152If Me._nodeSet.Contains(node) AndAlso Me._computeReplacementNode IsNot Nothing Then 167If Me._tokenSet.Contains(token) AndAlso Me._computeReplacementToken IsNot Nothing Then 181If Me._triviaSet.Contains(trivia) AndAlso Me._computeReplacementTrivia IsNot Nothing Then

Microsoft.CodeAnalysis.Workspaces (61)

Diagnostics\SkippedHostAnalyzersInfo.cs (4)

90if (projectAnalyzerIds.Contains(hostAnalyzerId)) 136if (projectAnalyzerDiagnosticIds.Contains(descriptor.Id)) 154if (projectAnalyzerDiagnosticIds.Contains(descriptor.SuppressedDiagnosticId) || 155projectSuppressedDiagnosticIds.Contains(descriptor.SuppressedDiagnosticId))

FindSymbols\FindReferences\DependentProjectsFinder.cs (1)

279var hasInternalsAccess = internalsVisibleToSet.Contains(project.AssemblyName);

FindSymbols\FindReferences\DependentTypeFinder.cs (3)

315if (seenPEReferences.Contains(peReference)) 516return baseType != null && set.Contains(baseType); 523if (set.Contains(interfaceType.OriginalDefinition))

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

163.Where(loc => documentIdsThatGetsAnnotatedAndRenamed.Contains(loc.DocumentId) && loc.Type == RelatedLocationType.PossiblyResolvableConflict && loc.IsReference) 179.Where(loc => documentIdsThatGetsAnnotatedAndRenamed.Contains(loc.DocumentId) && loc.Type == RelatedLocationType.PossiblyResolvableConflict) 318_documentOfRenameSymbolHasBeenRenamed |= documentIdsForConflictResolution.Contains(_documentIdOfRenameSymbolDeclaration); 448foreach (var unprocessedDocumentIdWithPotentialDeclarationConflicts in allDocumentIdsInProject.Where(d => !documentIdsForConflictResolution.Contains(d))) 749if (documentIds.Contains(document.Id))

Rename\ConflictEngine\RenamedSpansTracker.cs (1)

210.Where(x => !modifiedTokensInComplexifiedStatements.Contains((SyntaxToken)x))

Shared\Extensions\ISymbolExtensions.cs (1)

669!arg.overriddenSymbols.Contains(s) &&

Shared\Extensions\ITypeSymbolExtensions.cs (1)

109currentType.GetOriginalInterfacesAndTheirBaseInterfaces().Contains(interfaceType.OriginalDefinition);

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

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

212TryAddToWorker(declarations, checkGeneratedCode, out declaration, out availableIndices, d => ancestors.Contains(d)) ||

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

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (2)

32while (nameSet.Contains(result)) 123while (usedNames.Contains(updatedName) || !canUse(updatedName))

Utilities\WeakSet`1.cs (1)

32return _values.Contains(ReferenceHolder<T>.Strong(value));

Workspace\ProjectSystem\ProjectSystemProject.cs (2)

1069if (_projectAnalyzerPaths.Contains(mappedFullPath)) 1115if (!_projectAnalyzerPaths.Contains(mappedFullPath))

Workspace\Solution\ProjectChanges.cs (6)

29if (!oldRefs.Contains(reference)) 41if (!newRefs.Contains(reference)) 53if (!oldMetadata.Contains(metadata)) 65if (!newMetadata.Contains(metadata)) 77if (!oldAnalyzerReferences.Contains(analyzerReference)) 89if (!newAnalyzerReferences.Contains(analyzerReference))

Workspace\Solution\SolutionChanges.cs (2)

68if (!oldAnalyzerReferences.Contains(analyzerReference)) 80if (!newAnalyzerReferences.Contains(analyzerReference))

Workspace\Solution\SolutionCompilationState.cs (2)

336static (projectId, dependentProjects) => !dependentProjects.Contains(projectId), 384static (projectId, dependentProjects) => !dependentProjects.Contains(projectId),

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

988ThrowExceptionIfFalse(syntaxTreesInWorkspaceStates.Contains(tree), "The tree in the Compilation should have been from the workspace.");

Workspace\Solution\SolutionState.cs (3)

445if (addedProjectIds.Contains(projectReference.ProjectId)) 478var newProjectIds = ProjectIds.Where(p => !projectIdsSet.Contains(p)).ToBoxedImmutableArray(); 479var newProjectStates = SortedProjectStates.WhereAsArray(static (p, projectIdsSet) => !projectIdsSet.Contains(p.Id), projectIdsSet);

Workspace\Solution\SolutionState_Checksum.cs (1)

114if (projectConeId != null && !projectCone.Object.Contains(projectState.Id))

Workspace\Solution\TextDocumentStates.cs (1)

170if (ids.All(static (id, set) => set.Contains(id), set))

Workspace\Workspace.cs (2)

388if (!changedDocumentIds.Contains(relatedDocumentId)) 1657if (!infoChangedDocumentIds.Contains(docId))

Workspace\Workspace_Editor.cs (1)

184openDocuments.Contains(documentId);

Microsoft.CodeAnalysis.Workspaces.MSBuild (3)

MSBuild\MSBuildProjectLoader.Worker.cs (2)

155if (!processedPaths.Contains(projectPath)) 480if (paths.Contains(doc.FilePath))

MSBuild\MSBuildProjectLoader.Worker_ResolveReferences.cs (1)

171if (!_indicesToRemove.Contains(index) && set.Add(reference))

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (2)

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

Microsoft.CodeAnalysis.Workspaces.UnitTests (1)

FindReferencesTests.cs (1)

416Assert.True(projectIds.Contains(netCoreProject.Id));

Microsoft.CSharp (2)

Microsoft\CSharp\RuntimeBinder\SymbolTable.cs (2)

71if (s_namesLoadedForEachType.Contains(key)) 144Debug.Assert(!s_namesLoadedForEachType.Contains(key));

Microsoft.Data.Analysis (3)

DataFrame.Join.cs (2)

302if (!intersection.Contains(supplementaryRowIndex)) 393if (!intersection.Contains(i))

IDataView.Extension.cs (1)

60if (dataViewColumn.IsHidden || (selectColumnsSet != null && !selectColumnsSet.Contains(dataViewColumn.Name)))

Microsoft.Data.Analysis.Tests (3)

DataFrame.IOTests.cs (1)

1721if (possibleTypes.Contains(type))

DataFrameTests.Merge.cs (2)

779if (left.Columns["Int"][i] != null && intersection.Contains((int)left.Columns["Int"][i])) 795if (right.Columns["Int"][i] != null && intersection.Contains((int)right.Columns["Int"][i]))

Microsoft.DotNet.ArcadeLogging (1)

PipelinesLogger.cs (1)

240if (_ignoredTargets.Contains(e.TargetNames))

Microsoft.DotNet.Build.Tasks.Installers (1)

src\CreateRpmPackage.cs (1)

127if (!ownedDirectories.Contains(entry.Name))

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

ApplyMetaPackages.cs (2)

131(value.Contains("All") || value.Contains(tfm.DotNetFrameworkName));

FilterUnknownPackages.cs (1)

47isKnownPackage = packageId => baseLinePackageIds.Contains(packageId);

GeneratePackageReport.cs (1)

270if (s_ignoredFrameworks.Contains(derivedFx.Framework))

GetLayoutFiles.cs (1)

85if (rid != null && rids.Count > 0 && !rids.Contains(rid))

GetPackageDestination.cs (1)

90!suppressions.Contains(packageFx))

HarvestPackage.cs (1)

377if (preserveRefVersion.Contains(liveFile.Version))

PackageIndex.cs (4)

111if (!IndexSources.Contains(otherIndexFile)) 321isStable = info.StableVersions.Contains(packageVersion); 435bool existingStable = StableVersions.Contains(existingPackageVersion); 436bool updateStable = StableVersions.Contains(packageVersion);

UpdatePackageIndex.cs (2)

307.Where(pair => pair.Value == packageVersion && !assmVersions.Contains(pair.Key)) 354return (_packageIdsToInclude != null) ? _packageIdsToInclude.Contains(packageId) : true;

ValidateFrameworkPackage.cs (2)

51var logMissingInbox = permittedInbox.Contains(name) ? 75var logMissingPackage = permittedMissingInbox.Contains(missingInboxAssembly.Key) ?

ValidatePackage.cs (4)

339if (!implementationAssembly.TargetFramework.Equals(fx) && !runtimeFxSuppression.Contains(fx.ToString())) 405if (!info.StableVersions.Contains(packageVersion) && packageVersion != thisPackageVersion) 413.Where(pair => pair.Value == thisPackageVersion && !assemblyVersions.Contains(pair.Key)) 543if (explicitlySupportedFrameworks.Contains(fx))

ValidationTask.cs (2)

81return values.Contains(value); 92return frameworkValues.Any(fx => values.Contains(fx));

Microsoft.DotNet.CodeAnalysis (1)

Analyzers\PinvokeAnalyzer.cs (1)

115if (_isNotSupportedOnWin7.Contains(methodName))

Microsoft.DotNet.GenFacades (4)

SourceGenerator.cs (2)

56IEnumerable<string> typesToForward = compileFiles == null ? _referenceTypes : _referenceTypes.Where(id => !existingTypes.Contains(id)); 63if (!ignoreMissingTypes && !_ignoreMissingTypesList.Contains(type))

TypeParser.cs (2)

65if (!types.Contains(fullyQualifiedName)) 88if (!types.Contains(fullyQualifiedName))

Microsoft.DotNet.Helix.Sdk (1)

CheckAzurePipelinesTestResults.cs (1)

227if (expectedFailures.Contains(testName))

Microsoft.DotNet.PackageTesting (2)

VerifyClosure.cs (1)

188if (!otherFiles.Contains(moduleReference))

VerifyTypes.cs (1)

57if (ignoredTypes.Contains(type))

Microsoft.DotNet.SharedFramework.Sdk (4)

src\CreateFrameworkListFile.cs (1)

244!singleFileHostIncludeFilenames.Contains(f.Filename))

src\FileUtilities.cs (1)

34if (!s_assemblyExtensions.Contains(Path.GetExtension(path)))

src\Microsoft.DotNet.PackageTesting\VerifyClosure.cs (1)

188if (!otherFiles.Contains(moduleReference))

src\Microsoft.DotNet.PackageTesting\VerifyTypes.cs (1)

57if (ignoredTypes.Contains(type))

Microsoft.DotNet.SignCheckLibrary (1)

Verification\Exclusion.cs (1)

180=> cache.TryGetValue(key, out var cachedValues) && values.Any(cachedValues.Contains);

Microsoft.DotNet.SignTool (7)

src\BatchSignUtil.cs (3)

225var repackList = files.Where(w => toRepackSet.Contains(w.FullPath)).ToList(); 301trackedSet.Contains(x.FileSignInfo.FileContentKey)) && !toRepackSet.Contains(x.FileSignInfo.FullPath)

src\Configuration.cs (2)

519if (SignToolConstants.SignableExtensions.Contains(extension)) 847return _itemsToSkip3rdPartyCheck != null && _itemsToSkip3rdPartyCheck.Contains(Path.GetFileName(fileName));

src\SignTool.cs (1)

68var osxFilesToZip = filesToSign.Where(fsi => SignToolConstants.MacSigningOperationsRequiringZipping.Contains(fsi.SignInfo.Certificate));

src\SignToolTask.cs (1)

434if (!extension.Equals(Path.GetExtension(extension)) && !specialExtensions.Contains(extension))

Microsoft.DotNet.SourceBuild.Tasks (2)

src\UsageReport\WritePackageUsageData.cs (1)

209.Where(id => properties.Contains(id.Id + "/" + id.Version.OriginalVersion)))

src\UsageReport\WriteUsageReports.cs (1)

152EndsUpInOutput = poisonNupkgFilenames.Contains($"{id}.{version}")

Microsoft.DotNet.XliffTasks (1)

Model\VsctDocument.cs (1)

23if (nonUniqueIds.Contains(id))

Microsoft.DotNet.XUnitAssert.Tests (1)

Utility\ReadOnlySet.cs (1)

17 public bool Contains(T item) => hashSet.Contains(item);

Microsoft.Extensions.AI.Evaluation.Console (1)

Commands\CleanResultsCommand.cs (1)

72if (!toPreserve.Contains(executionName))

Microsoft.Extensions.AI.Evaluation.Quality (3)

IntentResolutionEvaluator.cs (1)

122if (toolCalls.Any(t => !toolDefinitionNames.Contains(t.Name)))

TaskAdherenceEvaluator.cs (1)

121if (toolCalls.Any(t => !toolDefinitionNames.Contains(t.Name)))

ToolCallAccuracyEvaluator.cs (1)

130if (toolCalls.Any(t => !toolDefinitionNames.Contains(t.Name)))

Microsoft.Extensions.ApiDescription.Client (1)

MetadataSerializer.cs (1)

129if (CharsToEscapeHash.Contains(@char))

Microsoft.Extensions.Configuration.Binder (2)

ConfigurationBinder.cs (2)

235if (!propertyNames.Contains(cs.Key)) 637if (!propertyNames.Contains(name))

Microsoft.Extensions.DependencyInjection (1)

ServiceLookup\CallSiteFactory.cs (1)

635if (!bestConstructorParameterTypes.Contains(p.ParameterType))

Microsoft.Extensions.DependencyInjection.AutoActivation (4)

AutoActivationExtensions.cs (2)

35if (ao.AutoActivators.Contains(constructed)) 69if (ao.AutoActivators.Contains(constructed))

AutoActivationExtensions.Keyed.cs (2)

34if (ao.KeyedAutoActivators.Contains((constructed, serviceKey))) 72if (ao.KeyedAutoActivators.Contains((constructed, serviceKey)))

Microsoft.Extensions.Diagnostics.Testing (1)

Metrics\MetricCollector.cs (1)

110if (!_supportedTs.Contains(typeof(T)))

Microsoft.Extensions.FileSystemGlobbing (1)

Internal\MatcherContext.cs (1)

85_declaredLiteralFolderSegmentInString.Contains(candidate.Name))

Microsoft.Extensions.Http (1)

DependencyInjection\HttpClientBuilderExtensions.cs (1)

586options.ShouldRedactHeaderValue = (header) => sensitiveHeaders.Contains(header);

Microsoft.Extensions.Logging.Generators (1)

LoggerMessageGenerator.Parser.cs (1)

696if (shadowedNames.Contains(parameter.Name))

Microsoft.Extensions.Options.DataAnnotations (1)

DataAnnotationValidateOptions.cs (1)

78if (visited is not null && visited.Contains(options))

Microsoft.Extensions.Options.SourceGeneration (1)

Parser.cs (1)

286var baseMembers = baseType.GetMembers().Where(m => !addedMembers.Contains(m.Name));

Microsoft.Extensions.ServiceDiscovery (2)

ServiceDiscoveryHttpClientBuilderExtensions.cs (2)

67_global = _options.ClientNames.Contains(null); 76if (_global || _options.ClientNames.Contains(builder.Name))

Microsoft.Gen.ComplianceReports (2)

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

Microsoft.Gen.ContextualOptions (2)

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

Microsoft.Gen.Logging (6)

Parsing\Parser.cs (1)

718if (shadowedNames.Contains(parameter.Name))

Parsing\Parser.LogProperties.cs (1)

338_allowedTypeKinds.Contains(symType.TypeKind) &&

Parsing\Parser.Records.cs (2)

107overriddenMembers.Contains(property.Name)) 134if (typesChain.Contains(extractedType))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

Microsoft.Gen.MetadataExtractor (3)

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

414if (!_allowedGenericAttributeTypeArgs.Contains(genericType.SpecialType))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

Microsoft.Gen.Metrics (3)

Parser.cs (1)

414if (!_allowedGenericAttributeTypeArgs.Contains(genericType.SpecialType))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

Microsoft.Gen.MetricsReports (3)

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

414if (!_allowedGenericAttributeTypeArgs.Contains(genericType.SpecialType))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

Microsoft.Interop.ComInterfaceGenerator (1)

Analyzers\ConvertComImportToGeneratedComInterfaceAnalyzer.cs (1)

94if (s_unsupportedTypeNames.Contains(info.ManagedType.FullTypeName))

Microsoft.Interop.LibraryImportGenerator (20)

Analyzers\ConvertToLibraryImportAnalyzer.cs (1)

159if (s_unsupportedTypeNames.Contains(info.ManagedType.FullTypeName))

Analyzers\CustomMarshallerAttributeFixer.cs (19)

Microsoft.Maui (3)

Hosting\Internal\RegisteredHandlerServiceTypeSet.cs (2)

34 if (_concreteHandlerServiceTypeSet.Contains(type) 35 || _interfaceHandlerServiceTypeSet.Contains(type))

Platform\ElementExtensions.cs (1)

78 if (handlersWithConstructors.Contains(viewType))

Microsoft.Maui.Controls (6)

Element\Element.cs (1)

663 bool waitForHandlerUpdateToFireFromBP = _pendingHandlerUpdatesFromBPSet.Contains(propertyName);

ListProxy.cs (1)

185 if (_indexesCounted.Contains(index))

Shell\ShellUriHandler.cs (3)

405 if (routeKeys.Contains(searchPath)) 413 if (routeKeys.Contains(segment)) 598 if (routeKeys.Contains(possibleRoutePath.NextSegment))

TemplatedItemsList.cs (1)

1294 if (_attachedItems.Contains(list))

Microsoft.Maui.Controls.DesignTools (2)

ColorDesignTypeConverter.cs (1)

199 if (knowValuesSet.Contains(str.Trim()))

VisibilityDesignTypeConverter.cs (1)

20 return supportedValues.Contains(strValue);

Microsoft.ML.AutoML (5)

AutoMLExperiment\ITrialResultManager.cs (1)

61if (_trialResultsHistory.Contains(result))

PipelineSuggesters\PipelineSuggester.cs (2)

80if (!visitedPipelines.Contains(suggestedPipeline)) 114return history.Where(h => selectedTrainerNames.Contains(h.Pipeline.Trainer.TrainerName))

TransformInference\TransformInference.cs (2)

482if (!existingColNames.Contains(desiredColName)) 491if (!existingColNames.Contains(newColName))

Microsoft.ML.CodeGenerator (6)

CodeGenerator\CSharp\CodeGenerator.cs (6)

111if (_lightGbmTrainers.Contains(currentNode.Name)) 115else if (_mklComponentsTrainers.Contains(currentNode.Name)) 119else if (_fastTreeTrainers.Contains(currentNode.Name)) 123else if (_imageTransformers.Contains(currentNode.Name)) 127else if (_imageClassificationTrainers.Contains(currentNode.Name)) 131else if (_recommendationTrainers.Contains(currentNode.Name))

Microsoft.ML.Core (1)

Data\ProgressReporter.cs (1)

450unseen = _infos.Where(x => !seen.Contains(x.Index)).ToArray();

Microsoft.ML.Core.Tests (2)

UnitTests\TestEntryPoints.cs (1)

306if (excludeSet.Contains(ep["Name"].ToString()))

UnitTests\TestVBuffer.cs (1)

334if (aIndices.Contains(i))

Microsoft.ML.Data (22)

Data\DataViewTypeManager.cs (1)

180if (_bannedRawTypes.Contains(type))

DataLoadSave\Binary\BinarySaver.cs (2)

587using (DataViewRowCursor cursor = data.GetRowCursor(data.Schema.Where(c => activeSet.Contains(c.Index)))) 745using (DataViewRowCursor cursor = data.GetRowCursor(data.Schema.Where(x => active.Contains(x.Index)), rand))

DataView\CacheDataView.cs (1)

350cursor = _subsetInput.GetRowCursor(_subsetInput.Schema.Where(c => taskColumns.Contains(c.Index)));

DataView\Transposer.cs (1)

885return activeSrcSet.Contains;

Evaluators\EvaluatorBase.cs (1)

81return i => pred(i) || stratIndices.Contains(i);

Model\Pfa\BoundPfaContext.cs (5)

71if (toDrop.Contains(name)) 76string fieldName = ModelUtils.CreateNameCore(name, fieldNames.Contains); 137string fieldName = ModelUtils.CreateNameCore(name, fieldNames.Contains); 275if (_unavailable.Contains(name)) 289return !_unavailable.Contains(name) && _nameToVarName.TryGetValue(name, out name) && (name == "input" || name.StartsWith("input."));

Model\Pfa\PfaContext.cs (4)

161if (_variables.Contains(l.Key)) 175if (!_variables.Contains(l.Key)) 209public bool ContainsVar(string name) => _variables.Contains(name); 213public bool ContainsType(string name) => _types.Contains(name);

Model\Pfa\SavePfaCommand.cs (1)

193if (_outputsToDrop.Contains(name))

Scorers\RowToRowScorerBase.cs (1)

172Func<int, bool> activeInfos = iinfo => activeIndices.Contains(bindings.MapIinfoToCol(iinfo));

Transforms\MetadataDispatcher.cs (2)

238if (kinds != null && kinds.Contains(kvp.Key)) 367return new Builder(this, index, schemaSrc, indexSrc, (k, i) => set.Contains(k));

Transforms\TransformBase.cs (1)

825return activeIndices.Contains(col);

Transforms\ValueMapping.cs (1)

294if (valueSet.Contains(v))

Transforms\ValueToKeyMappingTransformer.cs (1)

587using (var cursor = trainingData.GetRowCursor(trainingData.Schema.Where(c => toTrain.Contains(c.Index))))

Microsoft.ML.Ensemble (1)

PipelineEnsemble.cs (1)

100return InputSchema.Where(col => _inputColIndices.Contains(col.Index));

Microsoft.ML.FastTree (1)

Training\DocumentPartitioning.cs (1)

268if (categoricalIndices.Contains(hotFeature - 1))

Microsoft.ML.InternalCodeAnalyzer (1)

ContractsCheckAnalyzer.cs (1)

191if ((!(isCheck = name.StartsWith("Check")) && !(isExcept = name.StartsWith("Except"))) || !_targetSet.Contains(name))

Microsoft.ML.OnnxConverter (9)

OnnxContextImpl.cs (5)

68public override bool IsVariableDefined(string variableName) => _variableNames.Contains(variableName); 121Contracts.Assert(_variableNames.Contains(columnName)); 133return GetUniqueName(prefix, _nodeNames.Contains); 149_host.Assert(!_nodeNames.Contains(node.Name)); 220_columnNameMap[colName] = makeUniqueName ? GetUniqueName(colName, _variableNames.Contains) : colName;

SaveOnnxCommand.cs (4)

174if (inputColumnNamesToDrop.Contains(colName)) 200if (inputColumnNamesToDrop.Contains(idataviewColumnName) || outputColumnNamesToDrop.Contains(idataviewColumnName)) 272if (outputColumnNames.Contains(col.Name))

Microsoft.ML.OnnxTransformer (2)

OnnxUtils.cs (2)

536if (!_onnxTypeMap.Contains(typeof(T))) 556if (!_onnxTypeMap.Contains(typeof(T)))

Microsoft.ML.Predictor.Tests (1)

TestTransposer.cs (1)

127if (forceDenseSlotSet.Contains(i) || rgen.NextDouble() < density)

Microsoft.ML.Tests (2)

Scenarios\ClusteringTests.cs (1)

78Assert.True(!labels.Contains(scores.SelectedClusterId));

Transformers\CustomMappingTests.cs (1)

155output.FirstAppearance = !state.SeenValues.Contains(input.Value);

Microsoft.ML.TimeSeries (1)

PredictionEngine.cs (1)

175bool wantsActive = activeIndices.Contains(c);

Microsoft.ML.Transforms (3)

LoadTransform.cs (1)

94bool found = allTags.Contains(tag.ToLower());

MutualInformationFeatureSelection.cs (1)

195CreateDropAndCopyColumns(colArr.Length, scores, threshold, tiedScoresToKeep, _columns.Where(col => colSet.Contains(col.inputColumnName)).ToArray(), out int[] selectedCount, out dropSlotsColumns, out copyColumnPairs);

OptionalColumnTransform.cs (1)

382return activeIndices.Contains(col);

Microsoft.VisualStudio.LanguageServices (6)

ChangeSignature\ChangeSignatureDialogViewModel.cs (1)

506return _disabledParameters.Contains(parameterViewModel);

CommonControls\MemberSelectionViewModel.cs (1)

185if (!visited.Contains(dependent))

ErrorReporting\VisualStudioInfoBar.cs (1)

76if (_currentlyShowingMessages.Contains(message))

Library\ObjectBrowser\AbstractListItemFactory.cs (2)

359if (overriddenMembers != null && overriddenMembers.Contains(member)) 621if (assemblyIdentity != null && !assemblyIdentitySet.Contains(assemblyIdentity))

MoveStaticMembers\StaticMemberSelectionViewModel.cs (1)

99if (!visited.Contains(dependent))

PresentationBuildTasks (2)

MS\Internal\Tasks\IncrementalCompileAnalyzer.cs (1)

397if (localMarkupPages.Contains(localRefFile.FilePath))

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (1)

1963return _all || (_names is not null && _names.Contains(elementName));

PresentationCore (2)

MS\Internal\Resources\ContentFileHelper.cs (1)

28if (_contentFiles.Contains(partName))

System\Windows\Automation\Peers\AutomationPeer.cs (1)

1918if(hs != null && hs.Contains(child))

PresentationFramework (7)

MS\Internal\WindowsRuntime\Generated\WinRT\Projections.cs (1)

210if (ProjectedRuntimeClassNames.Contains(runtimeClassName))

System\Windows\Markup\RestrictiveXamlXmlReader.cs (5)

141if (SafeTypesFromRegistry.Contains("*")) 153if (AllXamlNamespaces.Contains(xmlns)) 186if (type is null || SafeTypesFromRegistry.Contains("*") || _safeTypesSet.Contains(type) || SafeTypesFromRegistry.Contains(type.FullName))

System\Windows\Markup\XamlTypeMapperSchemaContext.cs (1)

367if (!_clrNamespaces.Contains(xamlNamespace))

Roslyn.Diagnostics.Analyzers (28)

AbstractDoNotCopyValue.cs (2)

508var currentIsHandled = _handledOperations.Contains(operation); 1641if (_handledOperations.Contains(operation))

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

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

212TryAddToWorker(declarations, checkGeneratedCode, out declaration, out availableIndices, d => ancestors.Contains(d)) ||

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

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (2)

32while (nameSet.Contains(result)) 123while (usedNames.Contains(updatedName) || !canUse(updatedName))

RulesetToEditorconfigConverter (1)

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

RunTests (1)

AssemblyScheduler.cs (1)

145var unmatchedRemoteTests = testHistory.Keys.Where(type => !matchedRemoteTests.Contains(type));

System.CodeDom (1)

src\libraries\Common\src\System\CSharpHelpers.cs (1)

126return s_fixedStringLookup.Contains(value);

System.Collections.Immutable (1)

System\Collections\Frozen\FrozenSet.cs (1)

135!source.Contains(default!) &&

System.ComponentModel.Composition (6)

System\ComponentModel\Composition\AttributedModel\AttributedPartCreationInfo.cs (2)

273if (!_contractNamesOnNonInterfaces.Contains(attributedExportDefinition.ContractName)) 298if (!_contractNamesOnNonInterfaces.Contains(attributedExportDefinition.ContractName))

System\ComponentModel\Composition\Hosting\CatalogExportProvider.CatalogChangeProxy.cs (1)

40!_removedParts.Contains(partAndExport.Item1));

System\ComponentModel\Composition\Hosting\CatalogExportProvider.cs (2)

675if (_rejectedParts.Contains(definition)) 1010return _parts.Contains(part);

System\ComponentModel\Composition\Hosting\FilteredCatalog.Traversal.cs (1)

72return new FilteredCatalog(_innerCatalog, traversalClosure.Contains);

System.Composition.Hosting (2)

System\Composition\Hosting\Core\ExportDescriptorRegistryUpdate.cs (2)

68if (@checked.Contains(dependency.Target)) 81if (@checked.Contains(dependency.Target))

System.Data.Common (2)

System\Data\TypeLimiter.cs (2)

237if (currentScope.m_allowedTypes.Contains(type)) 269if (s_allowedTypes.Contains(type))

System.Diagnostics.DiagnosticSource (1)

System\Diagnostics\DsesActivitySourceListener.cs (1)

133&& _listenToActivitySourceNames.Contains(activitySource.Name));

System.IO.Packaging (2)

System\IO\Packaging\XmlCompatibilityReader.cs (2)

1740return _all || (_names != null && _names.Contains(elementName)); 1791return _all || (_names != null && _names.Contains(itemName));

System.Linq.Expressions (5)

System\Dynamic\Utils\Helpers.cs (1)

26if (set.Contains(t))

System\Linq\Expressions\Compiler\LabelInfo.cs (1)

135if (_definitions.Contains(j))

System\Linq\Expressions\Interpreter\LabelInfo.cs (2)

180return definitions.Contains(scope); 233if (set.Contains(t))

System\Runtime\CompilerServices\RuntimeOps.ExpressionQuoter.cs (1)

188if (hidden.Contains(variable))

System.Linq.Parallel (1)

System\Linq\Parallel\QueryOperators\Binary\ExceptQueryOperator.cs (1)

294if (rightLookup.Contains(leftElement.First))

System.Private.CoreLib (16)

src\libraries\System.Private.CoreLib\src\Internal\Runtime\InteropServices\ComponentActivator.cs (1)

149if (s_loadedInDefaultContext.Contains(assemblyPath))

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\HashSet.cs (4)

1036if (!Contains(element)) 1111if (Contains(element)) 1537if (!other.Contains(item)) 1559if (!other.Contains(item))

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValues.cs (2)

53if (uniqueValues.Contains(string.Empty)) 103if (!unreachableValues.Contains(value))

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValuesBase.cs (1)

31return _uniqueValues.Contains(value);

src\System\Reflection\RuntimeCustomAttributeData.cs (8)

1989if (!all && !s_pca.Contains(caType)) 2008if (!all && !s_pca.Contains(caType!)) 2033if (!all && !s_pca.Contains(caType)) 2050if (!all && !s_pca.Contains(caType!)) 2073if (!all && !s_pca.Contains(caType)) 2100if (!all && !s_pca.Contains(caType!)) 2129if (!all && !s_pca.Contains(caType)) 2155if (!all && !s_pca.Contains(caType!))

System.Private.CoreLib.Generators (8)

IntrinsicsInSystemPrivateCoreLibAnalyzer.cs (5)

416if (symbol.ContainingType != null && !examinedSymbols.Contains(symbol.ContainingType)) 418if (symbol.BaseType != null && !examinedSymbols.Contains(symbol.BaseType)) 438if (symbol.ContainingType != null && !examinedSymbols.Contains(symbol.ContainingType)) 440if (symbol.BaseType != null && !examinedSymbols.Contains(symbol.BaseType)) 685if (onLoadData.NamedTypesToBeProtected.Contains(symbol.ContainingType))

NativeRuntimeEventSourceGenerator.cs (3)

119if (inclusionList.TryGetValue(providerName, out HashSet<string>? events) && events.Contains(eventName)) 124if (inclusionList.TryGetValue("*", out HashSet<string>? wildcardEvents) && wildcardEvents.Contains(eventName)) 210if (name is not null && mask is not null && usedKeywords.Contains(name))

System.Private.DataContractSerialization (2)

System\Runtime\Serialization\DataContract.cs (2)

1143if (previousCollectionTypes.Contains(itemType)) 2095if (checkedContracts.Contains(contractPairKey))

System.Private.Windows.Core (2)

System\Private\Windows\BinaryFormat\Deserializer\Deserializer.cs (1)

321if (_pendingSerializationInfoIds is not null && _pendingSerializationInfoIds.Contains(completed))

System\Private\Windows\BinaryFormat\Deserializer\ObjectRecordDeserializer.cs (1)

94|| (Deserializer.IncompleteObjects.Contains(valueRecord) && value.GetType().IsValueType));

System.Private.Windows.Core.TestUtilities (2)

BinarySerialization.cs (2)

34if (serializableTypes.Contains(fullName)) 49if (serializableTypes.Contains(fullName))

System.Private.Xml (5)

src\libraries\Common\src\System\CSharpHelpers.cs (1)

126return s_fixedStringLookup.Contains(value);

System\Xml\Core\XmlTextReaderImpl.cs (1)

8065if (_currentEntities.Contains(entity))

System\Xml\Dom\XmlLoader.cs (1)

702if (attr.Prefix == _doc.strXmlns && !prefixes.Contains(attr.LocalName))

System\Xml\Serialization\XmlSerializationILGen.cs (1)

119if (!_generatedMethods.Contains(mapping))

System\Xml\Serialization\XmlSerializationWriter.cs (1)

1469while (_usedPrefixes.Contains(++_tempNamespacePrefix)) { }

System.Resources.Extensions (2)

System\Resources\Extensions\BinaryFormat\Deserializer\Deserializer.cs (1)

326if (_pendingSerializationInfoIds is not null && _pendingSerializationInfoIds.Contains(completed))

System\Resources\Extensions\BinaryFormat\Deserializer\ObjectRecordDeserializer.cs (1)

93|| (Deserializer.IncompleteObjects.Contains(valueRecord) && value.GetType().IsValueType));

System.Runtime.Serialization.Schema (3)

System\Runtime\Serialization\Schema\CodeExporter.cs (2)

1379if (contractCodeDomInfo.GetMemberNames().Contains(memberName)) 1385if (!contractCodeDomInfo.GetMemberNames().Contains(uniqueMemberName))

System\Runtime\Serialization\Schema\ContractCodeDomInfo.cs (1)

60Debug.Assert(!names.Contains(memberName));

System.ServiceModel.Syndication (1)

System\ServiceModel\Syndication\SyndicationFeed.cs (1)

353private static bool IsValidDay(string day) => s_acceptedDays.Contains(day);

System.Text.Json.SourceGeneration (1)

JsonSourceGenerator.Parser.cs (1)

1816_builtInSupportTypes.Contains(type);

System.Text.RegularExpressions (8)

System\Text\RegularExpressions\RegexCharClass.cs (1)

337Debug.Assert(whitespaceSet.Contains((char)i) == char.IsWhiteSpace((char)i));

System\Text\RegularExpressions\RegexTreeAnalyzer.cs (6)

124if (results._containsCapture.Contains(child)) 133if (!isAtomicBySelf && (results._mayBacktrack?.Contains(child) == true)) 183public bool IsAtomicByAncestor(RegexNode node) => _isAtomicByAncestor.Contains(node); 191public bool MayContainCapture(RegexNode node) => !_complete || _containsCapture.Contains(node); 204public bool MayBacktrack(RegexNode node) => !_complete || (_mayBacktrack?.Contains(node) ?? false); 224public bool IsInLoop(RegexNode node) => !_complete || (_inLoops?.Contains(node) ?? false);

System\Text\RegularExpressions\Symbolic\SymbolicRegexNode.cs (1)

550if (!seenElems.Contains(elems[i]))

System.Text.RegularExpressions.Generator (9)

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCharClass.cs (1)

337Debug.Assert(whitespaceSet.Contains((char)i) == char.IsWhiteSpace((char)i));

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexTreeAnalyzer.cs (6)

UpgradeToGeneratedRegexAnalyzer.cs (2)

75methodNames.Contains(method.Name)) 102if (staticMethodsToDetect.Contains(method))

System.Windows.Controls.Ribbon (1)

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonMenuItemsPanel.cs (1)

222if (starLayoutTargets.Contains(child))

System.Windows.Forms (12)

System\Windows\Forms\ActiveX\AxHost.AxContainer.cs (3)

96if (control != _parent && !GetComponents().Contains(control)) 129if (_containerCache.Contains(control)) 288if (!allowContainingControls && control != _parent && !GetComponents().Contains(control))

System\Windows\Forms\Application.cs (1)

992if (form is null || processedForms.Contains(form))

System\Windows\Forms\Controls\ListView\ListView.ColumnHeaderCollection.cs (1)

276if (!usedIndices.Contains(header.DisplayIndex) && header.DisplayIndex >= 0 && header.DisplayIndex < values.Length)

System\Windows\Forms\Controls\PropertyGrid\PropertyGrid.cs (1)

1057if (typesWithEvents is not null && typesWithEvents.Contains(objectType))

System\Windows\Forms\Controls\WebBrowser\WebBrowserContainer.cs (2)

260if (ctl != _parent && !_components.Contains(ctl)) 305if (_containerCache.Contains(ctl))

System\Windows\Forms\ToolTip\ToolTip.cs (4)

850if (!_created.Contains(control) 874if (!_created.Contains(control) && control.IsHandleCreated && TopLevelControl is not null) 879if (_created.Contains(control)) 911if (_created.Contains(control) && handlesCreated && !DesignMode)

System.Windows.Forms.Design (7)

System\ComponentModel\Design\DesignSurfaceServiceContainer.cs (1)

44if (serviceType is not null && _fixedServices.Contains(serviceType))

System\ComponentModel\Design\Serialization\CodeDomDesignerLoader.cs (1)

1066if (!conflict && memberHash.Contains(finalName))

System\ComponentModel\Design\Serialization\DesignerSerializationManager.cs (1)

486if (_defaultProviderTable is null || !_defaultProviderTable.Contains(serializerType))

System\Windows\Forms\Design\Behavior\BehaviorService.cs (1)

825(_hitTestedGlyph is not null && !_dragEnterReplies.Contains(_hitTestedGlyph)))

System\Windows\Forms\Design\ControlCommandSet.cs (1)

324if (itemHash.Contains(parent) && parent != component)

System\Windows\Forms\Design\DataGridViewColumnCollectionDialog.cs (1)

229if (_userAddedColumns.Contains(_columnsPrivateCopy[i]))

System\Windows\Forms\Design\TabOrder.cs (1)

272if (_tabComplete is not null && !_tabComplete.Contains(control))

System.Windows.Forms.PrivateSourceGenerators (1)

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

219if (enumType is null || foundTypes.Contains(enumType))

System.Xaml (4)

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (1)

1963return _all || (_names is not null && _names.Contains(elementName));

System\Xaml\Context\NameFixupGraph.cs (1)

125return _uninitializedObjectsAtParseEnd.Contains(instance);

System\Xaml\InfosetObjects\XamlObjectWriter.cs (1)

1520if (setProperties.Contains(property))

System\Xaml\XamlObjectReader.cs (1)

1059if (!namesOfAttributableProperties.Contains(dependingProperty.Name))

Templates.Blazor.Tests (2)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

Templates.Blazor.WebAssembly.Auth.Tests (2)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

Templates.Blazor.WebAssembly.Tests (2)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

Templates.Mvc.Tests (2)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

Templates.Tests (2)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

Test.Utilities (19)

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

Text.Analyzers (28)

CodeAnalysisDictionary.cs (2)

105=> _unrecognizedWords.Contains(word); 108=> _recognizedWords.Contains(word);

src\Compilers\Core\Portable\InternalUtilities\SetWithInsertionOrder.cs (1)

87public bool Contains(T value) => _set?.Contains(value) ?? false;

src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (1)

1024if (!set.Contains(item))

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

272if (!applicableAttributeNodes.Contains(node))

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

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (2)

188if (set.Contains(ancestor)) 285if (commonAncestorsSet.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (1)

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.BasicBlockAnalysisData.cs (1)

165if (!set2.Contains(operation))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.DataFlowAnalyzer.FlowGraphAnalysisData.cs (1)

227if (write != null && operations.Contains(write))

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

320if (map.Contains(operation.TextSpan))

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferencesEditorConfigSerializer.cs (2)

90if (!referencedElements.Contains(symbolSpecification.ID)) 106if (!referencedElements.Contains(namingStyle.ID))

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

212TryAddToWorker(declarations, checkGeneratedCode, out declaration, out availableIndices, d => ancestors.Contains(d)) ||

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

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (2)

32while (nameSet.Contains(result)) 123while (usedNames.Contains(updatedName) || !canUse(updatedName))

xunit.assert (10)

Sdk\AssertHelper.cs (2)

446 if (expectedRefs.Contains(expected)) 449 if (actualRefs.Contains(actual))

Sdk\CollectionTracker.cs (1)

210 if (!dictionaryYKeys.Contains(key))

StringAsserts.cs (7)

933 if (ignoreLineEndingDifferences && charsLineEndings.Contains(expectedChar) && charsLineEndings.Contains(actualChar)) 938 else if (ignoreAllWhiteSpace && (charsWhitespace.Contains(expectedChar) || charsWhitespace.Contains(actualChar))) 943 else if (ignoreWhiteSpaceDifferences && charsWhitespace.Contains(expectedChar) && charsWhitespace.Contains(actualChar)) 1685 if (charsWhitespace.Contains(value[index]))