Contains

Backchannel\AppHostAuxiliaryBackchannel.cs (1)

83public bool SupportsV2 => _capabilities.Contains(AuxiliaryBackchannelCapabilities.V2);

Commands\Test\VSTest\VSTestArgumentConverter.cs (6)

110if (s_ignoredArguments.Contains(activeArgument)) 130if (s_ignoredArguments.Contains(argValues[0])) 184else if (s_switchArguments.Contains(activeArgument)) 186if (s_ignoredArguments.Contains(activeArgument)) 203else if (s_ignoredArguments.Contains(activeArgument)) 253if (s_ignoredArguments.Contains(activeArgument))

Analyzers\AnalyzerFormatter.cs (4)

235|| !diagnosticIds.Contains(diagnosticId)) 309if (!project.Documents.Any(d => d.FilePath is not null && formattablePaths.Contains(d.FilePath))) 331analyzer.SupportedDiagnostics.All(descriptor => excludeDiagnostics.Contains(descriptor.Id))) 338!analyzer.SupportedDiagnostics.Any(descriptor => diagnostics.Contains(descriptor.Id)))

Analyzers\AnalyzerRunner.cs (2)

56.Where(diagnostic => fixableCompilerDiagnostics.Contains(diagnostic.Id)) 88formattableDocumentPaths.Contains(diagnostic.Location.SourceTree.FilePath))

Analyzers\CodeAnalysisResult.cs (2)

23if (!_excludeDiagnostics.IsEmpty && _excludeDiagnostics.Contains(diagnostic.Id)) 28if (!_diagnostics.IsEmpty && !_diagnostics.Contains(diagnostic.Id))

Analyzers\Extensions.cs (1)

48if (document.FilePath is null || !formattablePaths.Contains(document.FilePath))

src\b310f676f7308b7f\SymbolUsageAnalysis.DataFlowAnalyzer.cs (1)

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

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\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)

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

RouteEmbeddedLanguage\FrameworkParametersCompletionProvider.cs (1)

60return TriggerCharacters.Contains(trigger.Character);

RouteEmbeddedLanguage\RoutePatternCompletionProvider.cs (1)

54return TriggerCharacters.Contains(trigger.Character);

src\5057ed6cf5d6323b\ImmutableSegmentedHashSet`1.cs (1)

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

Loader\CoreCLRAssemblyLoader.cs (2)

64if (MSBuildLoadContext.WellKnownAssemblyNames.Contains(assemblyName.Name)) 130if (!MSBuildLoadContext.WellKnownAssemblyNames.Contains(assemblyName.Name))

Loader\MSBuildLoadContext.cs (1)

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

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)"/>

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\b310f676f7308b7f\SymbolUsageAnalysis.DataFlowAnalyzer.cs (1)

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

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)

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\2e2796bccd1466f6\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (3)

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

src\b310f676f7308b7f\SymbolUsageAnalysis.DataFlowAnalyzer.cs (1)

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

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)

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\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\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\9547feb31df4cc5d\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (3)

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

src\9547feb31df4cc5d\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (1)

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

src\b310f676f7308b7f\SymbolUsageAnalysis.DataFlowAnalyzer.cs (1)

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

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\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)"/>

Binder\Binder_Patterns.cs (2)

671if (!decisionDag.ReachableLabels.Contains(whenTrueLabel)) 675else if (!decisionDag.ReachableLabels.Contains(whenFalseLabel))

Binder\Binder.ValueChecks.cs (2)

1323if (this.LockedOrDisposedVariables.Contains(localSymbol)) 1453if (this.LockedOrDisposedVariables.Contains(parameterSymbol))

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

962if (!reachableLabels.Contains(node.WhenTrueLabel)) 967else if (!reachableLabels.Contains(node.WhenFalseLabel))

FlowAnalysis\NullableWalker.cs (7)

1429if (inputParamNames.Contains(inputParam.Name) 2740Debug.Assert(ErrorFacts.NullableWarnings.Contains(MessageProvider.Instance.GetIdForErrorCode((int)errorCode))); 5391if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 5392(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 7749if (returnNotNullIfParameterNotNull?.Contains(parameter.Name) == true) 8465if (notNullIfParameterNotNull.Contains(notNullParameter.Name)) 10583var 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);

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

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

252if (!referencedTypeParameters.Contains(typeParameter))

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

Rename\CSharpRenameRewriterLanguageService.cs (1)

195_conflictLocations.Contains(node.Span) &&

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

252if (!referencedTypeParameters.Contains(typeParameter))

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

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

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

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

Completion\CompletionService_GetCompletions.cs (2)

225if (!lspProvider.TriggerCharacters.Contains(character)) 227Debug.Assert(lspProvider.TriggerCharacters.Contains(character),

Completion\CompletionService.ProviderManager.cs (1)

237if (!y.Contains(v))

Copilot\IProposalAdjusterService.cs (1)

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

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);

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

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

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\9547feb31df4cc5d\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (3)

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

src\9547feb31df4cc5d\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\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\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))

UnusedReferences\ProjectAssets\ProjectAssetsReader.cs (1)

81if (autoReferences.Contains(referenceName))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\CollectionPropertiesShouldBeReadOnly.cs (1)

115property.Type.AllInterfaces.Any(i => knownTypes.ImmutableInterfaces.Contains(i.OriginalDefinition)))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotDirectlyAwaitATask.cs (1)

43!context.Options.GetOutputKindsOption(Rule, tree, context.Compilation).Contains(context.Compilation.Options.OutputKind))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\EventsShouldNotHaveBeforeOrAfterPrefix.cs (1)

58s_invalidPrefixes.Contains(firstWord) &&

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\ExceptionsShouldBePublic.cs (2)

56if (s_excludedOutputKinds.Contains(csContext.Compilation.Options.OutputKind)) 80if (symbol.BaseType != null && exceptionTypes.Contains(symbol.BaseType))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldNotContainTypeNames.cs (1)

130if (s_typeNames.Contains(identifier))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldNotHaveIncorrectSuffix.cs (1)

315=> !allowedSuffixes.Contains(suffix) && name.HasSuffix(suffix);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldNotMatchKeywords.cs (3)

113return GetSymbolKindsToAnalyze(context, rule).Contains(context.Symbol.Kind); 128if (!GetSymbolKindsToAnalyze(context, NamespaceRule).Contains(SymbolKind.Namespace)) 218if (!GetSymbolKindsToAnalyze(context, MemberParameterRule).Contains(SymbolKind.Parameter) ||

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\UsePropertiesWhereAppropriate.cs (1)

92taskTypes.Contains(methodSymbol.ReturnType.OriginalDefinition) ||

Microsoft.CodeQuality.Analyzers\Maintainability\DoNotIgnoreMethodResults.cs (2)

239methodNames.Contains(methodSymbol.Name) && 330s_stringMethodNames.Contains(method.Name);

Microsoft.CodeQuality.Analyzers\Maintainability\MakeTypesInternal.cs (1)

40|| !context.Options.GetOutputKindsOption(Rule, firstSyntaxTree, compilation, DefaultOutputKinds).Contains(compilation.Options.OutputKind))

Microsoft.CodeQuality.Analyzers\QualityGuidelines\UseLiteralsWhereAppropriate.cs (1)

95!constantIncompatibleTypes.Contains(fieldInitializerType))

Microsoft.NetCore.Analyzers\InteropServices\DisableRuntimeMarshallingAnalyzer.AutoLayoutTypeCache.cs (1)

45if (seenTypes.Contains(type.OriginalDefinition))

Microsoft.NetCore.Analyzers\InteropServices\PlatformCompatibilityAnalyzer.cs (1)

529else if (value.AnalysisValues.Contains(new PlatformMethodValue(info.PlatformName, EmptyVersion, false)))

Microsoft.NetCore.Analyzers\Performance\DoNotUseAsParallelInForEachLoop.cs (1)

93if (asParallelMethods.Contains(methodToCheck.OriginalDefinition))

Microsoft.NetCore.Analyzers\Performance\PreferHashDataOverComputeHash.cs (1)

498if (!SpecialManagedHashAlgorithms.Contains(originalHashType.Name))

Microsoft.NetCore.Analyzers\Performance\UseCountProperly.cs (4)

201if (!syncMethods.Contains(originalDefinition)) 203if (!asyncMethods.Contains(originalDefinition)) 504else if (allowedTypesForCA1836.Contains(type.OriginalDefinition) && 534if (allowedTypesForCA1836.Contains(type.OriginalDefinition) &&

Microsoft.NetCore.Analyzers\Performance\UseSearchValues.cs (1)

69if (!indexOfAnyMethodsToDetect.Contains(invocation.TargetMethod))

Microsoft.NetCore.Analyzers\Runtime\AvoidUnreliableStreamRead.cs (1)

148return _knownReliableStreamTypes.Contains(type);

Microsoft.NetCore.Analyzers\Runtime\DisposableFieldsShouldBeDisposed.cs (2)

130disposeAnalysisHelper.GetDisposableFields(field.ContainingType).Contains(field)) 163!disposeAnalysisHelper.GetDisposableFields(field.ContainingType).Contains(field))

Microsoft.NetCore.Analyzers\Runtime\DoNotPassLiteralsAsLocalizedParameters.cs (1)

250if (typesToIgnore.Contains(parameterSymbol.ContainingType) ||

Microsoft.NetCore.Analyzers\Runtime\DoNotRaiseReservedExceptionTypes.cs (2)

133if (tooGenericExceptionSymbols.Contains(typeSymbol)) 137else if (reservedExceptionSymbols.Contains(typeSymbol))

Microsoft.NetCore.Analyzers\Runtime\SpecifyIFormatProvider.cs (2)

235if (correctOverload != null && !superfluousFormatProviderOverloads.Contains(correctOverload)) 337if (validToStringMethods.Contains(targetMethod))

Microsoft.NetCore.Analyzers\Security\ApprovedCipherModeAnalyzer.cs (1)

68&& UnsafeCipherModes.Contains(fieldSymbol.MetadataName))

Microsoft.NetCore.Analyzers\Security\DataSetDataTableInIFormatterSerializableObjectGraphAnalyzer.cs (4)

94&& SecurityHelpers.BinaryFormatterDeserializationMethods.Contains(methodName)) 96&& SecurityHelpers.NetDataContractSerializerDeserializationMethods.Contains(methodName)) 98&& SecurityHelpers.ObjectStateFormatterDeserializationMethods.Contains(methodName)) 100&& SecurityHelpers.SoapFormatterDeserializationMethods.Contains(methodName)))

Microsoft.NetCore.Analyzers\Security\DoNotUseDeprecatedSecurityProtocols.cs (1)

202if (HardCodedSafeProtocolMetadataNames.Contains(fieldReferenceOperation.Field.Name))

Microsoft.NetCore.Analyzers\Security\DoNotUseDSA.cs (2)

135if (s_DSAAlgorithmNames.Contains(argValue.ToString())) 151if (s_DSAAlgorithmNames.Contains(argValueForFirstParameter.ToString()))

Microsoft.NetCore.Analyzers\Security\DoNotUseInsecureDeserializerJavascriptSerializerWithSimpleTypeResolver.cs (2)

178&& SecurityHelpers.JavaScriptSerializerDeserializationMethods.Contains(invocationOperation.TargetMethod.Name)) 196&& SecurityHelpers.JavaScriptSerializerDeserializationMethods.Contains(methodReferenceOperation.Method.Name))

Microsoft.NetCore.Analyzers\Security\DoNotUseInsecureDeserializerJsonNetWithoutBinder.cs (1)

158&& SecurityHelpers.JsonSerializerDeserializationMethods.Contains(

Microsoft.NetCore.Analyzers\Security\DoNotUseInsecureDeserializerMethodsBase.cs (2)

90&& cachedDeserializationMethodNames.Contains(invocationOperation.TargetMethod.MetadataName)) 112&& cachedDeserializationMethodNames.Contains(methodReferenceOperation.Method.MetadataName))

Microsoft.NetCore.Analyzers\Security\DoNotUseInsecureDeserializerWithoutBinderBase.cs (2)

143&& cachedDeserializationMethodNames.Contains(invocationOperation.TargetMethod.Name)) 159&& cachedDeserializationMethodNames.Contains(

Microsoft.NetCore.Analyzers\Security\DoNotUseInsecureSettingsForJsonNet.cs (2)

167&& SecurityHelpers.JsonSerializerInstantiateWithSettingsMethods.Contains(invocationOperation.TargetMethod.Name) 171&& SecurityHelpers.JsonSerializerInstantiateWithSettingsMethods.Contains(invocationOperation.TargetMethod.Name)

Microsoft.NetCore.Analyzers\Security\DoNotUseWeakKDFAlgorithm.cs (1)

81!s_WeakHashAlgorithmNames.Contains(propertyReferenceOperation.Property.Name) &&

Microsoft.NetCore.Analyzers\Security\SourceTriggeredTaintedDataAnalyzerBase.cs (1)

238if (!sourceSink.SinkKinds.Contains(this.SinkKind))

Microsoft.NetCore.Analyzers\Security\SslProtocolsAnalyzer.cs (1)

230if (HardcodedSslProtocolsMetadataNames.Contains(fieldReferenceOperation.Field.Name))

Microsoft.NetCore.Analyzers\Security\UseRSAWithSufficientKeySize.cs (2)

133s_RSAAlgorithmNames.Contains(argValue.ToString())) 150s_RSAAlgorithmNames.Contains(argValue.ToString()))

Microsoft.NetCore.Analyzers\Security\UseSharedAccessProtocolHttpsOnly.cs (1)

157!protocolsArgument.LiteralValues.Contains(SharedAccessProtocolHttpsOnly))

Microsoft.NetCore.Analyzers\Usage\ImplementGenericMathInterfacesCorrectly.cs (1)

145return s_knownInterfaces.Contains(anInterface.MetadataName) &&

Microsoft.NetFramework.Analyzers\TypesShouldNotExtendCertainBaseTypes.cs (1)

72badBaseTypes.Contains(namedTypeSymbol.BaseType) &&

src\0437c1690f5501bd\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\40daf5e1cab76dff\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (3)

666if (sanitizerInfo.SanitizingInstanceMethods.Contains(method.MetadataName)) 700&& sinkParameters.Contains(taintedArgument.Parameter.MetadataName)) 733if (sinkInfo.SinkProperties.Contains(propertyReferenceOperation.Member.MetadataName))

src\40daf5e1cab76dff\TaintedDataSymbolMapExtensions.cs (2)

117if (sourceInfo.TaintedProperties.Contains(propertySymbol.MetadataName)) 225if (sourceInfo.TransferProperties.Contains(name))

src\9382845807600969\AnalysisEntityDataFlowOperationVisitor.cs (1)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\ImmutableHashSetExtensions.cs (4)

46return set2.Contains(set1.First()) ? set1 : ImmutableHashSet<T>.Empty; 50return set1.Contains(set2.First()) ? set2 : ImmutableHashSet<T>.Empty; 56if (set2.Contains(item)) 83if (!set2.Contains(item))

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\UriExtensions.cs (1)

69if (s_uriWords.Contains(word))

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Analysis\CopyAnalysis\CopyAbstractValue.cs (2)

58Debug.Assert(AnalysisEntities.Contains(entityToRemove)); 67Debug.Assert(entitiesToRemove.All(AnalysisEntities.Contains));

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Analysis\CopyAnalysis\CopyAnalysisData.cs (3)

143if (!newCopyEntities.Contains(predicatedCopyEntity)) 211Debug.Assert(kvp.Value.AnalysisEntities.Contains(kvp.Key)); 227Debug.Assert(kvp.Value.AnalysisEntities.Contains(defaultCopyValyeEntity));

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Analysis\DisposeAnalysis\DisposeAnalysisHelper.cs (1)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\PointsToAnalysisResult.cs (2)

57=> _trackedEntities.Contains(analysisEntity); 60=> _trackedPointsToValues.Contains(value);

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAnalysis.cs (2)

220if (!enclosingResult.VisitedLocalFunctions.Contains(localFunctionSymbol)) 232if (!enclosingResult.VisitedLambdas.Contains(flowAnonymousFunctionOperation))

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (3)

221=> _lValueFlowCaptures.Contains(flowCapture.Id); 994return _lazyContractCheckMethods.Contains(method); 2968if (_lValueFlowCaptures.Contains(operation.Id))

Language\Components\TypeNameHelper.cs (2)

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

src\b310f676f7308b7f\SymbolUsageAnalysis.DataFlowAnalyzer.cs (1)

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

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)

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

Symbols\Source\SourceFieldSymbol.vb (3)

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

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)

Rename\VisualBasicRenameRewriterLanguageService.vb (2)

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

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_FindReferencesInDocuments.cs (1)

65if (!projectsToSearch.Contains(currentProject))

FindSymbols\FindReferences\FindReferencesSearchEngine.cs (1)

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

SolutionCrawler\InvocationReasons.cs (1)

28=> _reasons.Contains(reason);

src\b310f676f7308b7f\SymbolUsageAnalysis.DataFlowAnalyzer.cs (1)

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

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)"/>

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));

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);

MSBuild\SolutionFileReader.cs (1)

67if (!projectFilter.Contains(absoluteProjectPath))

AssemblySymbolLoader.cs (1)

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

FileWatcher\DirectoryWatcher.cs (1)

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

HotReload\HotReloadDotNetWatcher.cs (1)

677if (!projectPathSet.Contains(projectPath))

MarshallingInfoParser.cs (2)

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

TypeSymbolExtensions.cs (1)

149if (seenTypes.Contains(type))

src\b310f676f7308b7f\SymbolUsageAnalysis.DataFlowAnalyzer.cs (1)

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

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)

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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\MethodGenerator.cs (1)

252if (!referencedTypeParameters.Contains(typeParameter))

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

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