Contains

src\msbuild\artifacts\.packages\microsoft.codeanalysis.collections\5.0.0-1.25277.114\contentFiles\cs\net9.0\Segmented\ImmutableSegmentedHashSet`1.cs (1)

143/// <inheritdoc cref="ImmutableHashSet{T}.Contains(T)"/>

Microsoft.Build.Framework (2)

Loader\CoreCLRAssemblyLoader.cs (1)

115if (!MSBuildLoadContext.WellKnownAssemblyNames.Contains(assemblyName.Name))

Loader\MSBuildLoadContext.cs (1)

52if (WellKnownAssemblyNames.Contains(assemblyName.Name!))

Microsoft.CodeAnalysis (23)

Collections\ImmutableHashSetExtensions.cs (1)

34if (!set.Contains(item))

CommandLine\AnalyzerConfig.cs (2)

246if (ReservedKeys.Contains(key) || ReservedValues.Contains(value))

DiagnosticAnalyzer\AnalysisResult.cs (2)

122if (excludedAnalyzers.Contains(diagnosticsByAnalyzer.Key)) 139if (excludedAnalyzers.Contains(diagnosticsByAnalyzer.Key))

DiagnosticAnalyzer\AnalysisScope.cs (2)

184Debug.Assert(_lazyAnalyzersSet.Value.Contains(analyzer)); 188return _lazyAnalyzersSet.Value.Contains(analyzer);

DiagnosticAnalyzer\AnalyzerDriver.cs (12)

DiagnosticAnalyzer\CompilationWithAnalyzers.cs (1)

372analyzers = analyzers.AddRange(suppressors.Where(suppressor => !suppressorsInAnalysisScope.Contains(suppressor)));

InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

SourceGeneration\AdditionalSourcesCollection.cs (1)

113if (_reservedHintNames.Contains(hintName))

src\roslyn\src\Dependencies\Collections\Segmented\ImmutableSegmentedHashSet`1.cs (1)

143/// <inheritdoc cref="ImmutableHashSet{T}.Contains(T)"/>

Microsoft.CodeAnalysis.Analyzers (19)

FixAnalyzers\FixerWithFixAllAnalyzer.cs (1)

183if (invocation.TargetMethod is IMethodSymbol invocationSym && _analysisTypes.CreateMethods.Contains(invocationSym))

MetaAnalyzers\CompareSymbolsCorrectlyAnalyzer.cs (2)

216possibleMethodTypes.Contains(method.ContainingType.OriginalDefinition) && 265collectionTypes.Contains(createdType.OriginalDefinition) &&

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (2)

352else if (diagnosticCreateMethods.Contains(invocation.TargetMethod)) 1322return !CADiagnosticIdAllowedAssemblies.Contains(assemblyName);

MetaAnalyzers\RegisterActionAnalyzer.cs (1)

367!s_supportedSymbolKinds.Contains(symbol.Name))

MetaAnalyzers\ReportDiagnosticAnalyzer.cs (1)

204!_contextTypes.Contains(symbol.ContainingType))

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

src\roslyn\src\Dependencies\Collections\Segmented\ImmutableSegmentedHashSet`1.cs (1)

143/// <inheritdoc cref="ImmutableHashSet{T}.Contains(T)"/>

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

82filteredFieldsForComplexity.Contains((IFieldSymbol)child.Symbol))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

371if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 377return method.ContainingType.AllInterfaces.Any(i => iCollectionTypes.Contains(i.OriginalDefinition));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ImmutableHashSetExtensions.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\EditorConfigParser.cs (2)

96if (ReservedKeys.Contains(key) || ReservedValues.Contains(value))

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

183if (!_analysisData.CapturedLocals.Contains(local))

Microsoft.CodeAnalysis.AnalyzerUtilities (35)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

src\roslyn\src\Dependencies\Collections\Segmented\ImmutableSegmentedHashSet`1.cs (1)

143/// <inheritdoc cref="ImmutableHashSet{T}.Contains(T)"/>

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

82filteredFieldsForComplexity.Contains((IFieldSymbol)child.Symbol))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

371if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 377return method.ContainingType.AllInterfaces.Any(i => iCollectionTypes.Contains(i.OriginalDefinition));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ImmutableHashSetExtensions.cs (4)

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\CopyAnalysis\CopyAbstractValue.cs (2)

59Debug.Assert(AnalysisEntities.Contains(entityToRemove)); 68Debug.Assert(entitiesToRemove.All(AnalysisEntities.Contains));

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\CopyAnalysis\CopyAnalysis.CopyDataFlowOperationVisitor.cs (4)

108if (assignedValue.AnalysisEntities.Contains(targetAnalysisEntity)) 181Debug.Assert(existingValue.AnalysisEntities.Contains(analysisEntity)); 252if (assignedValue.AnalysisEntity != null && !assignedEntities.Contains(assignedValue.AnalysisEntity)) 545Debug.Assert(copyValue.AnalysisEntities.Contains(key));

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\CopyAnalysis\CopyAnalysisData.cs (3)

144if (!newCopyEntities.Contains(predicatedCopyEntity)) 212Debug.Assert(kvp.Value.AnalysisEntities.Contains(kvp.Key)); 228Debug.Assert(kvp.Value.AnalysisEntities.Contains(defaultCopyValyeEntity));

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\DisposeAnalysis\DisposeAnalysisHelper.cs (1)

159=> (s_DisposableCreationKinds.Contains(operation.Kind) ||

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\PointsToAnalysisResult.cs (2)

59=> _trackedEntities.Contains(analysisEntity); 62=> _trackedPointsToValues.Contains(value);

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAnalysis.cs (2)

221if (!enclosingResult.VisitedLocalFunctions.Contains(localFunctionSymbol)) 233if (!enclosingResult.VisitedLambdas.Contains(flowAnonymousFunctionOperation))

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

668if (sanitizerInfo.SanitizingInstanceMethods.Contains(method.MetadataName)) 702&& sinkParameters.Contains(taintedArgument.Parameter.MetadataName)) 735if (sinkInfo.SinkProperties.Contains(propertyReferenceOperation.Member.MetadataName))

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

118if (sourceInfo.TaintedProperties.Contains(propertySymbol.MetadataName)) 226if (sourceInfo.TransferProperties.Contains(name))

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

280Debug.Assert(addressSharedCopyValue.AnalysisEntities.Contains(targetAnalysisEntity));

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

224=> _lValueFlowCaptures.Contains(flowCapture.Id); 997return _lazyContractCheckMethods.Contains(method); 2971if (_lValueFlowCaptures.Contains(operation.Id))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\EditorConfigParser.cs (2)

96if (ReservedKeys.Contains(key) || ReservedValues.Contains(value))

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

183if (!_analysisData.CapturedLocals.Contains(local))

Microsoft.CodeAnalysis.CodeStyle (16)

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

320return _lazySupportedCompilerErrorCodes.Value.Contains(errorCode); 427if (!idsToAnalyze.Contains(descriptor.Id))

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

1068=> methodSymbol.GetAttributes().Any(static (a, self) => self._attributeSetForMethodsToIgnore.Contains(a.AttributeClass), this);

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (3)

555var hasReference = symbolUsageResult.SymbolsRead.Contains(unusedParameter); 634!resultFromFlowAnalysis.SymbolsRead.Contains(localSymbol); 779isSymbolRead |= symbolUsageResult.SymbolsRead.Contains(parameter);

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (1)

241if (method.GetAttributes().Any(static (a, self) => a.AttributeClass is { } attributeClass && self._attributeSetForMethodsToIgnore.Contains(attributeClass), this))

src\roslyn\src\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (4)

111if (s_nonEnumerableReturningLinqPredicateMethodNames.Contains(method.Name) || 112s_nonEnumerableReturningLinqSelectorMethodNames.Contains(method.Name)) 158if (isWhereMethod && !s_nonEnumerableReturningLinqPredicateMethodNames.Contains(name)) 161if (isSelectMethod && !s_nonEnumerableReturningLinqSelectorMethodNames.Contains(name))

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

src\roslyn\src\Dependencies\Collections\Segmented\ImmutableSegmentedHashSet`1.cs (1)

143/// <inheritdoc cref="ImmutableHashSet{T}.Contains(T)"/>

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\EditorConfigParser.cs (2)

96if (ReservedKeys.Contains(key) || ReservedValues.Contains(value))

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

183if (!_analysisData.CapturedLocals.Contains(local))

Microsoft.CodeAnalysis.CSharp (31)

Binder\Binder.ValueChecks.cs (2)

1327if (this.LockedOrDisposedVariables.Contains(localSymbol)) 1457if (this.LockedOrDisposedVariables.Contains(parameterSymbol))

Binder\Binder_Patterns.cs (2)

568if (!decisionDag.ReachableLabels.Contains(whenTrueLabel)) 572else if (!decisionDag.ReachableLabels.Contains(whenFalseLabel))

Binder\DecisionDagBuilder_CheckOrReachability.cs (1)

530bool shouldReport = !dag.ReachableLabels.Contains(@case.CaseLabel) && !labelsToIgnore.Contains(@case.CaseLabel);

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

779if (!actualUnmanagedCallingConventionTypes.Contains(((CSharpCustomModifier)expectedModifier).ModifierSymbol))

Binder\SwitchBinder_Patterns.cs (1)

87return !reachableLabels.Contains(switchLabel.Label);

Binder\SwitchExpressionBinder.cs (2)

78if (!hasErrors && !reachableLabels.Contains(arm.Label)) 85if (!reachableLabels.Contains(defaultLabel))

Compilation\CSharpCompilation.cs (1)

3286if (!trackingSet.Contains(otherTree))

Compilation\CSharpDiagnosticFilter.cs (1)

157bool isNullableFlowAnalysisWarning = ErrorFacts.NullableWarnings.Contains(id);

FlowAnalysis\AbstractFlowPass.cs (2)

1010if (!reachableLabels.Contains(node.WhenTrueLabel)) 1015else if (!reachableLabels.Contains(node.WhenFalseLabel))

FlowAnalysis\AbstractFlowPass_Switch.cs (3)

51if (reachableLabels.Contains(label.Label) || label.HasErrors || 74if (node.ReachabilityDecisionDag.ReachableLabels.Contains(node.BreakLabel) || 166if (!reachableLabels.Contains(arm.Label) || arm.Pattern.HasErrors)

FlowAnalysis\NullableWalker.cs (7)

1429if (inputParamNames.Contains(inputParam.Name) 2738Debug.Assert(ErrorFacts.NullableWarnings.Contains(MessageProvider.Instance.GetIdForErrorCode((int)errorCode))); 5393if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 5394(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 7722if (returnNotNullIfParameterNotNull?.Contains(parameter.Name) == true) 8438if (notNullIfParameterNotNull.Contains(notNullParameter.Name)) 10556var returnNotNull = operandState.IsNotNull() && method.ReturnNotNullIfParameterNotNull.Contains(method.Parameters[0].Name);

Lowering\ClosureConversion\ClosureConversion.cs (1)

209return _allCapturedVariables.Contains(localOrParameter);

Symbols\Source\ConstantEvaluationHelpers.cs (3)

307if (node.Dependencies.Contains(stopAt)) 347Debug.Assert(n.DependedOnBy.Contains(field)); 355Debug.Assert(n.Dependencies.Contains(field));

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (1)

1368if (notNullIfParameterNotNull.Contains(overrideParam.Name) && NullableWalker.GetParameterState(baseParam.TypeWithAnnotations, baseParam.FlowAnalysisAnnotations).IsNotNull)

Symbols\TypeSymbol.cs (1)

2460if (!overriddenMembers.Contains(baseAbstractMember))

Utilities\ValueSetFactory.EnumeratedValueSet.cs (2)

82return _included == _membersIncludedOrExcluded.Contains(value); 102return _membersIncludedOrExcluded.Contains(value);

Microsoft.CodeAnalysis.CSharp.CodeStyle (4)

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (2)

390if (BannedTypes.Contains(member?.ContainingType.Name)) 395if (BannedTypes.Contains(type?.Name))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (1)

1065if (BannedTypes.Contains(type.Name))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)

426if (typeParams.Any(static (p, delegateTypeParamNames) => delegateTypeParamNames.Contains(p.Name), delegateTypeParamNames))

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

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

252if (!referencedTypeParameters.Contains(typeParameter))

Microsoft.CodeAnalysis.CSharp.Features (8)

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

321if (!currentParameterNames.Contains(overloadParameter.Name) &&

Completion\CompletionProviders\EnumAndCompletionListTagCompletionProvider.cs (1)

131if (context.Trigger.Kind == CompletionTriggerKind.Insertion && s_triggerCharacters.Contains(context.Trigger.Character))

Completion\CompletionProviders\FileBasedPrograms\AbstractAppDirectiveCompletionProvider.cs (1)

36return TriggerCharacters.Contains(text[characterPosition])

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs (1)

228=> s_predefinedTypeMetadataNames.Contains(identifier);

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (2)

390if (BannedTypes.Contains(member?.ContainingType.Name)) 395if (BannedTypes.Contains(type?.Name))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (1)

1065if (BannedTypes.Contains(type.Name))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)

426if (typeParams.Any(static (p, delegateTypeParamNames) => delegateTypeParamNames.Contains(p.Name), delegateTypeParamNames))

Microsoft.CodeAnalysis.CSharp.Workspaces (2)

Rename\CSharpRenameRewriterLanguageService.cs (1)

195_conflictLocations.Contains(node.Span) &&

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

252if (!referencedTypeParameters.Contains(typeParameter))

Microsoft.CodeAnalysis.Extensions.Package (1)

src\roslyn\src\Dependencies\Collections\Segmented\ImmutableSegmentedHashSet`1.cs (1)

143/// <inheritdoc cref="ImmutableHashSet{T}.Contains(T)"/>

Microsoft.CodeAnalysis.Features (28)

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

28if (diagnosticIds.Contains(IDEDiagnosticIds.RemoveUnnecessarySuppressionDiagnosticId))

Completion\CompletionService.ProviderManager.cs (1)

237if (!y.Contains(v))

Completion\CompletionService_GetCompletions.cs (2)

215if (!lspProvider.TriggerCharacters.Contains(character)) 217Debug.Assert(lspProvider.TriggerCharacters.Contains(character),

Copilot\IProposalAdjusterService.cs (1)

141if (allowableAdjustments is null || !allowableAdjustments.Contains(adjusterName))

Diagnostics\Service\DiagnosticAnalyzerService.HostAnalyzerInfo.cs (2)

41=> _hostAnalyzers.Contains(analyzer); 140if (referenceIdsToRedirectAsProjectAnalyzers.Contains(referenceId))

Diagnostics\Service\DiagnosticAnalyzerService_DeprioritizationCandidates.cs (1)

78if (deprioritizedIds.Contains(id))

Diagnostics\Service\DiagnosticAnalyzerService_ProduceProjectDiagnostics.cs (2)

46if (diagnosticIds != null && _analyzerInfoCache.GetDiagnosticDescriptors(analyzer).All(d => !diagnosticIds.Contains(d.Id))) 155=> diagnosticIds == null || diagnosticIds.Contains(diagnostic.Id);

EditAndContinue\EditAndContinueDiagnosticDescriptors.cs (1)

282=> s_noEffectDiagnosticIds.Contains(diagnostic.Id);

EditAndContinue\EditSession.cs (1)

1383static _ => false : (Func<ISymbol, bool>)projectChanges.AddedSymbols.Contains;

EmbeddedLanguages\DateAndTime\DateAndTimeEmbeddedCompletionProvider.cs (1)

46if (TriggerCharacters.Contains(trigger.Character))

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

53return TriggerCharacters.Contains(trigger.Character);

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

28=> _reasons.Contains(reason);

FindUsages\AbstractFindUsagesService.ProgressAdapter.cs (1)

93var isPrimary = group.Symbols.Contains(symbol.OriginalDefinition);

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

320return _lazySupportedCompilerErrorCodes.Value.Contains(errorCode); 427if (!idsToAnalyze.Contains(descriptor.Id))

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

1068=> methodSymbol.GetAttributes().Any(static (a, self) => self._attributeSetForMethodsToIgnore.Contains(a.AttributeClass), this);

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (3)

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (1)

241if (method.GetAttributes().Any(static (a, self) => a.AttributeClass is { } attributeClass && self._attributeSetForMethodsToIgnore.Contains(attributeClass), this))

src\roslyn\src\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (4)

UnusedReferences\ProjectAssets\ProjectAssetsReader.cs (1)

81if (autoReferences.Contains(referenceName))

Microsoft.CodeAnalysis.Razor.Compiler (2)

Language\Components\TypeNameHelper.cs (2)

63if (PredefinedTypeNames.Contains(typeName.AsMemory())) 120if (PredefinedTypeNames.Contains(typeName))

Microsoft.CodeAnalysis.ResxSourceGenerator (12)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

src\roslyn\src\Dependencies\Collections\Segmented\ImmutableSegmentedHashSet`1.cs (1)

143/// <inheritdoc cref="ImmutableHashSet{T}.Contains(T)"/>

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

82filteredFieldsForComplexity.Contains((IFieldSymbol)child.Symbol))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

371if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 377return method.ContainingType.AllInterfaces.Any(i => iCollectionTypes.Contains(i.OriginalDefinition));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ImmutableHashSetExtensions.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\EditorConfigParser.cs (2)

96if (ReservedKeys.Contains(key) || ReservedValues.Contains(value))

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

183if (!_analysisData.CapturedLocals.Contains(local))

Microsoft.CodeAnalysis.VisualBasic (3)

Symbols\Source\SourceFieldSymbol.vb (3)

411Debug.Assert(n.DependedOnBy.Contains(field)) 418Debug.Assert(n.Dependencies.Contains(field)) 558If node.Dependencies.Contains(stopAt) Then

Microsoft.CodeAnalysis.VisualBasic.Features (4)

Completion\CompletionProviders\CompletionUtilities.vb (2)

48If CommonTriggerChars.Contains(ch) Then 60CommonTriggerChars.Contains(ch) OrElse

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.vb (2)

168Return _aliasedNames.Contains(identifier) 172Return s_predefinedTypeMetadataNames.Contains(identifier)

Microsoft.CodeAnalysis.VisualBasic.Workspaces (2)

Rename\VisualBasicRenameRewriterLanguageService.vb (2)

169_conflictLocations.Contains(node.Span) AndAlso 249If Me._conflictLocations.Contains(node.Span) Then

Microsoft.CodeAnalysis.Workspaces (35)

CodeFixes\FixAllOccurrences\FixAllContext.cs (1)

248return [.. diagnostics.Where(d => d != null && diagnosticIds.Contains(d.Id)

Diagnostics\DiagnosticIdFilter.cs (2)

49IncludedDiagnosticIds.Contains(id)) 57!ExcludedDiagnosticIds.Contains(id))

Diagnostics\Extensions.cs (1)

140if (skippedAnalyzersInfo.SkippedAnalyzers.Contains(analyzer))

FindSymbols\FindReferences\FindReferenceCache.cs (1)

105if (_aliasNameSet.Contains(token.ValueText))

FindSymbols\FindReferences\FindReferencesSearchEngine.cs (1)

191Contract.ThrowIfFalse(group.Symbols.Contains(symbol), "Symbol group did not contain the very symbol we started with.");

FindSymbols\FindReferences\FindReferencesSearchEngine_FindReferencesInDocuments.cs (1)

65if (!projectsToSearch.Contains(currentProject))

SolutionCrawler\InvocationReasons.cs (1)

28=> _reasons.Contains(reason);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

src\roslyn\src\Dependencies\Collections\Segmented\ImmutableSegmentedHashSet`1.cs (1)

143/// <inheritdoc cref="ImmutableHashSet{T}.Contains(T)"/>

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\EditorConfigParser.cs (2)

96if (ReservedKeys.Contains(key) || ReservedValues.Contains(value))

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

183if (!_analysisData.CapturedLocals.Contains(local))

Workspace\Solution\ProjectDependencyGraph.cs (8)

137Contract.ThrowIfFalse(ProjectIds.Contains(projectId)); 156.Where(r => ProjectIds.Contains(r.ProjectId)) 495Debug.Assert(referencesMap.Keys.All(projectIds.Contains)); 502Debug.Assert(projectIds.Contains(referencedProject), "Unexpected reference to unknown project."); 517Debug.Assert(reverseReferencesMap.Keys.All(projectIds.Contains)); 524Debug.Assert(reverseReferencesMap[referencedProject].Contains(project)); 534Debug.Assert(forwardReferencesMap[referencingProject].Contains(project)); 571return forwardDependencies.Contains(potentialDependency);

Workspace\Solution\ProjectDependencyGraph_AddProjectReference.cs (3)

17Contract.ThrowIfFalse(ProjectIds.Contains(projectId)); 26.Where(r => ProjectIds.Contains(r.ProjectId)) 132if (projectIdToUpdate == projectId || existingTransitiveReferences?.Contains(projectId) == true)

Workspace\Solution\ProjectDependencyGraph_RemoveAllProjectReferences.cs (3)

16Contract.ThrowIfFalse(ProjectIds.Contains(projectId)); 87if (!references.Contains(projectId)) 114if (!references.Contains(projectId))

Workspace\Solution\ProjectDependencyGraph_RemoveProject.cs (2)

145if (references.Contains(removedProjectId)) 179if (references.Contains(removedProjectId))

Workspace\Solution\ProjectDependencyGraph_RemoveProjectReference.cs (6)

16Contract.ThrowIfFalse(ProjectIds.Contains(projectId)); 17Contract.ThrowIfFalse(_referencesMap[projectId].Contains(referencedProjectId)); 78if (!references.Contains(projectId)) 85Debug.Assert(references.Contains(referencedProjectId)); 106if (!references.Contains(referencedProjectId)) 139Debug.Assert(references.Contains(projectId));

Microsoft.CodeAnalysis.Workspaces.MSBuild (1)

MSBuild\SolutionFileReader.cs (1)

67if (!projectFilter.Contains(absoluteProjectPath))

Microsoft.DotNet.ApiSymbolExtensions (1)

AssemblySymbolLoader.cs (1)

444if (referenceAssemblyNamesToIgnore != null && referenceAssemblyNamesToIgnore.Contains(assemblyReferenceName))

Microsoft.DotNet.HotReload.Watch (2)

FileWatcher\DirectoryWatcher.cs (1)

32if (watchedFileNames.Count > 0 && !watchedFileNames.Contains(Path.GetFileName(fullPath)))

HotReload\HotReloadDotNetWatcher.cs (1)

662if (!projectPathSet.Contains(projectPath))

Microsoft.Interop.SourceGeneration (3)

MarshallingInfoParser.cs (2)

303if (inspectedElements.Contains(elementName)) 331if (paramName is not null && inspectedElements.Contains(paramName))

TypeSymbolExtensions.cs (1)

149if (seenTypes.Contains(type))

Roslyn.Diagnostics.Analyzers (12)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

src\roslyn\src\Dependencies\Collections\Segmented\ImmutableSegmentedHashSet`1.cs (1)

143/// <inheritdoc cref="ImmutableHashSet{T}.Contains(T)"/>

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

82filteredFieldsForComplexity.Contains((IFieldSymbol)child.Symbol))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

371if (!s_collectionAddMethodNameVariants.Contains(method.Name) && 377return method.ContainingType.AllInterfaces.Any(i => iCollectionTypes.Contains(i.OriginalDefinition));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ImmutableHashSetExtensions.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\EditorConfigParser.cs (2)

96if (ReservedKeys.Contains(key) || ReservedValues.Contains(value))

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

183if (!_analysisData.CapturedLocals.Contains(local))

Roslyn.Diagnostics.CSharp.Analyzers (1)

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

252if (!referencedTypeParameters.Contains(typeParameter))

System.Collections.Immutable (2)

System\Collections\Immutable\ImmutableHashSet_1.cs (2)

802if (!other.Contains(e.Current)) 907if (!otherAsSet.Contains(item))