Contains

Implemented interface members:

method

Contains

System.Collections.Immutable.IImmutableSet<T>.Contains(T)

368 references to Contains

AnalyzerRunner (3)

CodeRefactoringRunner.cs (2)

81if (!syntaxKinds.Contains(node.RawKind)) 192else if (options.AnalyzerNames.Contains(refactoring.GetType().Name))

DiagnosticAnalyzerRunner.cs (1)

278else if (options.AnalyzerNames.Contains(analyzer.GetType().Name))

BuildActionTelemetryTable (3)

Program.cs (3)

148if (IgnoredCodeActions.Contains(actionTypeName)) 178if (IgnoredCodeActions.Contains(actionTypeName)) 217if (IgnoredCodeActions.Contains(actionOrProviderTypeName))

GenerateDocumentationAndConfigFiles (11)

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

178return set.Contains(v);

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

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

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

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

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

47return set2.Contains(set1.First()) ? set1 : ImmutableHashSet<T>.Empty; 51return set1.Contains(set2.First()) ? set2 : ImmutableHashSet<T>.Empty; 57if (set2.Contains(item)) 84if (!set2.Contains(item))

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

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

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

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

Metrics (12)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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

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

Metrics.Legacy (12)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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

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

Microsoft.AspNetCore.App.Analyzers (2)

RouteEmbeddedLanguage\FrameworkParametersCompletionProvider.cs (1)

60return TriggerCharacters.Contains(trigger.Character);

RouteEmbeddedLanguage\RoutePatternCompletionProvider.cs (1)

54return TriggerCharacters.Contains(trigger.Character);

Microsoft.CodeAnalysis (24)

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\AnalysisResultBuilder.cs (2)

543if (analyzers.Contains(diagnosticsByAnalyzer.Key)) 573if (analyzers.Contains(diagnosticsByAnalyzer.Key))

DiagnosticAnalyzer\AnalysisScope.cs (2)

185Debug.Assert(_lazyAnalyzersSet.Value.Contains(analyzer)); 189return _lazyAnalyzersSet.Value.Contains(analyzer);

DiagnosticAnalyzer\AnalyzerDriver.cs (12)

DiagnosticAnalyzer\CompilationWithAnalyzers.cs (1)

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

InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

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\Compilers\Core\Portable\InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.AnalyzerUtilities (35)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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\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\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\DisposeAnalysis\DisposeAnalysisHelper.cs (1)

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

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

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

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

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

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\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataSymbolMapExtensions.cs (2)

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

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

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

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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\EditorConfigParser.cs (2)

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

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

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

Microsoft.CodeAnalysis.BannedApiAnalyzers (12)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.CodeStyle (16)

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

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

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

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

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

539var hasReference = symbolUsageResult.SymbolsRead.Contains(unusedParameter); 614!resultFromFlowAnalysis.SymbolsRead.Contains(localSymbol); 759isSymbolRead |= symbolUsageResult.SymbolsRead.Contains(parameter);

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\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (4)

106if (s_nonEnumerableReturningLinqPredicateMethodNames.Contains(method.Name) || 107s_nonEnumerableReturningLinqSelectorMethodNames.Contains(method.Name)) 149if (isWhereMethod && !s_nonEnumerableReturningLinqPredicateMethodNames.Contains(name)) 152if (isSelectMethod && !s_nonEnumerableReturningLinqSelectorMethodNames.Contains(name))

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

178return set.Contains(v);

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

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

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

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

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

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

Microsoft.CodeAnalysis.Collections.Package (1)

Segmented\ImmutableSegmentedHashSet`1.cs (1)

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

Microsoft.CodeAnalysis.CSharp (30)

Binder\Binder.ValueChecks.cs (2)

1056if (this.LockedOrDisposedVariables.Contains(localSymbol)) 1186if (this.LockedOrDisposedVariables.Contains(parameterSymbol))

Binder\Binder_Patterns.cs (2)

132if (!decisionDag.ReachableLabels.Contains(whenTrueLabel)) 136else if (!decisionDag.ReachableLabels.Contains(whenFalseLabel))

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

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

Binder\SwitchBinder_Patterns.cs (1)

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

Binder\SwitchExpressionBinder.cs (2)

69if (!hasErrors && !reachableLabels.Contains(arm.Label)) 75if (!reachableLabels.Contains(defaultLabel))

Compilation\CSharpCompilation.cs (1)

3173if (!trackingSet.Contains(otherTree))

Compilation\CSharpDiagnosticFilter.cs (1)

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

FlowAnalysis\AbstractFlowPass.cs (2)

961if (!reachableLabels.Contains(node.WhenTrueLabel)) 966else 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)

1387if (inputParamNames.Contains(inputParam.Name) 2677Debug.Assert(ErrorFacts.NullableWarnings.Contains(MessageProvider.Instance.GetIdForErrorCode((int)errorCode))); 5065if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 5066(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 7344if (returnNotNullIfParameterNotNull?.Contains(parameter.Name) == true) 8038if (notNullIfParameterNotNull.Contains(notNullParameter.Name)) 9917var returnNotNull = operandState.IsNotNull() && method.ReturnNotNullIfParameterNotNull.Contains(parameter.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)

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

Symbols\TypeSymbol.cs (1)

2450if (!overriddenMembers.Contains(baseAbstractMember))

Utilities\ValueSetFactory.EnumeratedValueSet.cs (2)

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

Microsoft.CodeAnalysis.CSharp.CodeStyle (4)

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

389if (BannedTypes.Contains(member?.ContainingType.Name)) 394if (BannedTypes.Contains(type?.Name))

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

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

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

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

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

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

257if (!referencedTypeParameters.Contains(typeParameter))

Microsoft.CodeAnalysis.CSharp.Features (7)

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

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

Completion\CompletionProviders\EnumAndCompletionListTagCompletionProvider.cs (1)

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

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs (1)

228=> s_predefinedTypeMetadataNames.Contains(identifier);

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

389if (BannedTypes.Contains(member?.ContainingType.Name)) 394if (BannedTypes.Contains(type?.Name))

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

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

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

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

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

Diagnostics\DiagnosticTest.cs (1)

511if (ErrorFacts.NullableWarnings.Contains(MessageProvider.Instance.GetIdForErrorCode((int)error)))

Microsoft.CodeAnalysis.CSharp.Workspaces (2)

Rename\CSharpRenameRewriterLanguageService.cs (1)

195_conflictLocations.Contains(node.Span) &&

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

257if (!referencedTypeParameters.Contains(typeParameter))

Microsoft.CodeAnalysis.EditorFeatures (1)

Workspaces\AbstractTextBufferVisibilityTracker.cs (1)

108Contract.ThrowIfFalse(data.Callbacks.Contains(callback));

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (1)

CodeActions\CodeChangeProviderMetadataTests.cs (1)

103&& !predefinedNames.Contains(name))

Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver (1)

VisualBasic\Scanner.cs (1)

99if (Keywords.Contains(text))

Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver.UnitTests (1)

VisualBasicParsingTests.cs (1)

56Assert.True(MemberSignatureParser.Keywords.Contains(keyword));

Microsoft.CodeAnalysis.Extensions.Package (1)

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

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

Microsoft.CodeAnalysis.ExternalAccess.FSharp (1)

VS\IFSharpWorkspaceProjectContextFactory.cs (1)

146=> _metadataReferences.Contains(referencePath);

Microsoft.CodeAnalysis.Features (29)

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

29if (diagnosticIds.Contains(IDEDiagnosticIds.RemoveUnnecessarySuppressionDiagnosticId)) 55bool shouldIncludeDiagnostic(string id) => _diagnosticIds == null || _diagnosticIds.Contains(id);

Completion\CompletionService.ProviderManager.cs (1)

237if (!y.Contains(v))

Completion\CompletionService_GetCompletions.cs (2)

216if (!lspProvider.TriggerCharacters.Contains(character)) 218Debug.Assert(lspProvider.TriggerCharacters.Contains(character),

Diagnostics\Service\DocumentAnalysisExecutor.cs (2)

54? analysisScope.ProjectAnalyzers.WhereAsArray(compilationBasedProjectAnalyzers.Contains) 59? analysisScope.HostAnalyzers.WhereAsArray(compilationBasedHostAnalyzers.Contains)

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer.HostAnalyzerInfo.cs (2)

55if (referenceIdsToRedirectAsProjectAnalyzers.Contains(referenceId)) 121=> _hostAnalyzers.Contains(analyzer);

Diagnostics\Service\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnostics.cs (2)

97=> diagnosticIds == null || diagnosticIds.Contains(diagnostic.Id); 146if (diagnosticIds != null && this.DiagnosticAnalyzerInfoCache.GetDiagnosticDescriptors(analyzer).All(d => !diagnosticIds.Contains(d.Id)))

EditAndContinue\EditAndContinueDiagnosticDescriptors.cs (1)

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

EditAndContinue\EditSession.cs (1)

1159static _ => 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)

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

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

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

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

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

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

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\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (4)

UnusedReferences\ProjectAssets\ProjectAssetsReader.cs (1)

81if (autoReferences.Contains(referenceName))

Microsoft.CodeAnalysis.InteractiveHost (1)

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

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

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (12)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.PublicApiAnalyzers (12)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.PublicApiAnalyzers.CodeFixes (2)

DeclarePublicApiFix.cs (2)

172IEnumerable<string> newLines = lines.Where(line => !linesToRemove.Contains(line)); 308Debug.Assert(newSymbolNames.All(newSymbolName => !symbolNamesToRemove.Contains(newSymbolName)));

Microsoft.CodeAnalysis.ResxSourceGenerator (12)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.Test.Utilities (1)

Diagnostics\CommonDiagnosticAnalyzers.cs (1)

1152if (_symbolNames.Contains(type.Name))

Microsoft.CodeAnalysis.Threading.Package (1)

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

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

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 (33)

CodeFixes\FixAllOccurrences\FixAllContext.cs (1)

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

Diagnostics\Extensions.cs (1)

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

FindSymbols\FindReferences\FindReferenceCache.cs (1)

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

FindSymbols\FindReferences\FindReferencesSearchEngine.cs (1)

190Contract.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\Compilers\Core\Portable\InternalUtilities\MultiDictionary.cs (1)

178return set.Contains(v);

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

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

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

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

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.CodeAnalysis.Workspaces.MSBuild.BuildHost (2)

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

178return set.Contains(v);

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

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

Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (1)

NewlyCreatedProjectsFromDotNetNew.cs (1)

232.Where(id => !reportedDiagnosticIds.Contains(id));

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

MEF\TestComposition.cs (1)

126=> Assemblies.Contains(typeof(Remote.BrokeredServiceBase).Assembly);

Microsoft.Interop.SourceGeneration (3)

MarshallingInfoParser.cs (2)

301if (inspectedElements.Contains(elementName)) 329if (paramName is not null && inspectedElements.Contains(paramName))

TypeSymbolExtensions.cs (1)

149if (seenTypes.Contains(type))

Microsoft.VisualStudio.LanguageServices (6)

ProjectSystem\VisualStudioWorkspaceImpl.OpenFileTracker.cs (2)

161if (!workspace.IsDocumentOpen(documentId) && !_projectSystemProjectFactory.DocumentsNotFromFiles.Contains(documentId)) 324if (w.IsDocumentOpen(documentId) && !_projectSystemProjectFactory.DocumentsNotFromFiles.Contains(documentId))

PullMemberUp\SymbolDependentsBuilder.cs (2)

73_membersInType.Contains(memberReferenceOp.Member)) 82_membersInType.Contains(methodReferenceOp.TargetMethod))

TableDataSource\Suppression\VisualStudioSuppressionFixService.cs (1)

518.Where(d => latestDocumentDiagnostics.Contains(d) ||

TaskList\ExternalErrorDiagnosticUpdateSource.cs (1)

329=> GetOrCreateSupportedDiagnosticIds(projectId).Contains(id);

Roslyn.Diagnostics.Analyzers (12)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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

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

Roslyn.Diagnostics.CSharp.Analyzers (1)

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

257if (!referencedTypeParameters.Contains(typeParameter))

System.Collections.Immutable (1)

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

842if (!otherAsSet.Contains(item))

System.Windows.Forms.Tests (4)

System\Windows\Forms\Design\DesignerAttributeTests.cs (4)

83if (SkipList.Contains(attribute.DesignerTypeName)) 101if (SkipList.Contains(attribute.SerializerTypeName)) 159if (SkipList.Contains(attribute.ConverterTypeName)) 176if (SkipList.Contains(attribute.EditorTypeName))

Test.Utilities (11)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

Text.Analyzers (12)

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

178return set.Contains(v);

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

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

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

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

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

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

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

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

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

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

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