Contains

Implemented interface member:

459 references to Contains

dotnet-format (2)

Analyzers\AnalyzerFormatter.cs (2)

276if (id == "IDE0005" && fixer.FixableDiagnosticIds.Contains("RemoveUnnecessaryImportsFixable")) 281return fixer.FixableDiagnosticIds.Contains(id);

GenerateDocumentationAndConfigFiles (26)

src\roslyn\src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

950return other.Contains(array[0]); 952return other.Contains(array[0]) && other.Contains(array[1]); 954return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

src\roslyn\src\Dependencies\Collections\OneOrMany.cs (1)

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

177} while (ancestor != null && !ancestorKinds.Contains(ancestor.Kind));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

140(SymbolEqualityComparer.Default.Equals(type, interfaceType) || type.AllInterfaces.Contains(interfaceType));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxToken.cs (1)

54=> Diagnostics.Contains(diagnostic) ? this : With(diagnostics: this.Diagnostics.Add(diagnostic));

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

252=> descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.CompilationEnd);

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

30if (info.CandidateSymbols.Contains(null!))

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

169if (!y.SymbolSpecification.ApplicableAccessibilityList.Contains(accessibility)) 202if (!x.SymbolSpecification.RequiredModifierList.Contains(modifier)) 224if (!y.SymbolSpecification.ApplicableSymbolKindList.Contains(symbolKind))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (6)

302if (s_allApplicableKinds.All(symbols.Contains) && symbols.All(s_allApplicableKinds.Contains)) 400if (s_allAccessibility.All(accessibilities.Contains) && accessibilities.All(s_allAccessibility.Contains)) 459if (_allModifierKind.All(modifiers.Contains) && modifiers.All(_allModifierKind.Contains))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

39if (_symbolKindsThatCanBeOverridden.Contains(symbol.Kind) && DoesSymbolImplementAnotherSymbol(symbol))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (1)

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.cs (1)

46return type is INamedTypeSymbol { TypeKind: TypeKind.Interface } namedType && !allInterfaces.Contains(namedType)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

46=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

173=> this.SupportedLanguagesArray.Contains(languageName);

Microsoft.Analyzers.Extra.Tests (2)

Resources\RoslynTestUtils.cs (2)

346if (fixer.FixableDiagnosticIds.Contains(d.Id)) 544return diags.Where(d => _fixer.FixableDiagnosticIds.Contains(d.Id));

Microsoft.Analyzers.Local.Tests (2)

Resources\RoslynTestUtils.cs (2)

347if (fixer.FixableDiagnosticIds.Contains(d.Id)) 545return diags.Where(d => _fixer.FixableDiagnosticIds.Contains(d.Id));

Microsoft.Build (7)

src\msbuild\artifacts\.packages\microsoft.codeanalysis.collections\5.0.0-1.25277.114\contentFiles\cs\net9.0\Extensions\ImmutableArrayExtensions.cs (6)

1390return other.Contains(array[0]); 1392return other.Contains(array[0]) && other.Contains(array[1]); 1394return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

Microsoft.CodeAnalysis (27)

Compilation\Compilation.cs (1)

3328emitOptions.InstrumentationKinds.Contains(InstrumentationKind.TestCoverage),

DiagnosticAnalyzer\AnalysisResult.cs (1)

73if (!Analyzers.Contains(analyzer))

DiagnosticAnalyzer\AnalysisResultBuilder.cs (1)

315if (analysisScope.AdditionalFiles.Contains(additionalText))

DiagnosticAnalyzer\AnalysisScope.cs (1)

202Debug.Assert(compilationWithAnalyzers.Analyzers.Contains(analyzer));

DiagnosticAnalyzer\AnalyzerExecutor.cs (2)

374static (d, supportedSuppressions) => supportedSuppressions.Contains(d), 488if (symbolAction.Kinds.Contains(symbol.Kind))

DiagnosticAnalyzer\CompilationWithAnalyzers.cs (3)

151if (!_analyzers.Contains(analyzer)) 169if (analyzers.Any(static (a, self) => !self._analyzers.Contains(a), this)) 214if (!AdditionalFiles.Contains(file))

DiagnosticAnalyzer\DiagnosticAnalysisContext.cs (3)

1361if (!OperationBlocks.Contains(operationBlock)) 1494if (!OperationBlocks.Contains(operationBlock)) 1937if (!ReportedDiagnostics.Contains(suppression.SuppressedDiagnostic))

DiagnosticAnalyzer\DiagnosticStartAnalysisScope.cs (1)

545if (symbolKinds.Contains(SymbolKind.Parameter))

DiagnosticAnalyzer\SuppressMessageAttributeState.cs (1)

169if (diagnostic.CustomTags.Contains(WellKnownDiagnosticTags.Compiler))

Emit\EditAndContinue\SymbolMatcher.cs (1)

259Debug.Assert(isDeletedMemberMapping || newSynthesizedMembers.Contains(mappedMember));

Operations\ControlFlowGraphBuilder.cs (2)

6077Debug.Assert(validKinds.Contains(innerInitializer.Kind)); 6813if (_currentInterpolatedStringHandlerArgumentContext?.ApplicableCreationOperations.Contains(operation) == true)

Operations\ControlFlowGraphBuilder.InterpolatedStringContext.cs (1)

70Debug.Assert(_currentInterpolatedStringHandlerArgumentContext.ApplicableCreationOperations.Contains((IInterpolatedStringHandlerCreationOperation)operation));

SourceGeneration\GeneratorDriver.cs (1)

149if (generators.Contains(newGenerators[i]))

SourceGeneration\SyntaxStore.cs (1)

51Debug.Assert(_syntaxInputNodes.Contains(syntaxInputNode));

src\roslyn\src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

src\roslyn\src\Dependencies\Collections\OneOrMany.cs (1)

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

Microsoft.CodeAnalysis.Analyzers (31)

ImmutableObjectMethodAnalyzer.cs (1)

97&& type.GetBaseTypesAndThis().Any(immutableTypeSymbols.Contains))

MetaAnalyzers\DiagnosticAnalyzerAPIUsageAnalyzer.cs (2)

141s_WorkspaceAssemblyNames.Contains(usedType.ContainingAssembly.Name)) 268s_WorkspaceAssemblyNames.Contains(usedType.ContainingAssembly.Name))

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (1)

439!customTags.Contains(CompilationEndWellKnownDiagnosticTag) &&

MetaAnalyzers\ReportDiagnosticAnalyzer.cs (1)

243!_supportedDescriptorFieldsMap[(INamedTypeSymbol)symbolContext.Symbol].Contains(descriptorFields[0]))

src\roslyn\src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

src\roslyn\src\Dependencies\Collections\OneOrMany.cs (1)

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

177} while (ancestor != null && !ancestorKinds.Contains(ancestor.Kind));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

140(SymbolEqualityComparer.Default.Equals(type, interfaceType) || type.AllInterfaces.Contains(interfaceType));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxToken.cs (1)

54=> Diagnostics.Contains(diagnostic) ? this : With(diagnostics: this.Diagnostics.Add(diagnostic));

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

252=> descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.CompilationEnd);

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

30if (info.CandidateSymbols.Contains(null!))

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

39if (_symbolKindsThatCanBeOverridden.Contains(symbol.Kind) && DoesSymbolImplementAnotherSymbol(symbol))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (1)

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.cs (1)

46return type is INamedTypeSymbol { TypeKind: TypeKind.Interface } namedType && !allInterfaces.Contains(namedType)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

46=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

173=> this.SupportedLanguagesArray.Contains(languageName);

Microsoft.CodeAnalysis.AnalyzerUtilities (27)

src\roslyn\src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

src\roslyn\src\Dependencies\Collections\OneOrMany.cs (1)

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

177} while (ancestor != null && !ancestorKinds.Contains(ancestor.Kind));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

140(SymbolEqualityComparer.Default.Equals(type, interfaceType) || type.AllInterfaces.Contains(interfaceType));

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ValueContentAnalysis\ValueContentAnalysis.ValueContentDataFlowOperationVisitor.cs (1)

216DataFlowAnalysisContext.AdditionalSupportedValueTypes.Contains(namedType))

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

111if (ControlFlowGraph.LocalFunctions.Contains(localFunction))

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

635Debug.Assert(DataFlowAnalysisContext.ControlFlowGraph.LocalFunctions.Contains(localFunction));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxToken.cs (1)

54=> Diagnostics.Contains(diagnostic) ? this : With(diagnostics: this.Diagnostics.Add(diagnostic));

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

252=> descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.CompilationEnd);

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

30if (info.CandidateSymbols.Contains(null!))

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

39if (_symbolKindsThatCanBeOverridden.Contains(symbol.Kind) && DoesSymbolImplementAnotherSymbol(symbol))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (1)

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.cs (1)

46return type is INamedTypeSymbol { TypeKind: TypeKind.Interface } namedType && !allInterfaces.Contains(namedType)

Microsoft.CodeAnalysis.CodeStyle (30)

src\roslyn\src\Analyzers\Core\Analyzers\Helpers\DeserializationConstructorCheck.cs (1)

21methodSymbol.ContainingType.AllInterfaces.Contains(_iSerializableType);

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

1052if (_iNotifyCompletionType != null && memberSymbol.ContainingType.AllInterfaces.Contains(_iNotifyCompletionType) && memberSymbol.Name == "IsCompleted")

src\roslyn\src\Analyzers\Core\Analyzers\UseAutoProperty\AccessedFields.cs (1)

33=> Equals(TrivialField, field) || NonTrivialFields.Contains(field);

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerDiagnosticAnalyzer.cs (1)

149if (objectType.Type == null || !objectType.Type.AllInterfaces.Contains(ienumerableType))

src\roslyn\src\Analyzers\Core\Analyzers\UseThrowExpression\AbstractUseThrowExpressionDiagnosticAnalyzer.cs (4)

152if (dataFlow.ReadInside.Contains(localOrParameter) || 153dataFlow.WrittenInside.Contains(localOrParameter)) 162return exprDataFlow.ReadInside.Contains(localOrParameter) || 163exprDataFlow.WrittenInside.Contains(localOrParameter);

src\roslyn\src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

src\roslyn\src\Dependencies\Collections\OneOrMany.cs (1)

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxToken.cs (1)

54=> Diagnostics.Contains(diagnostic) ? this : With(diagnostics: this.Diagnostics.Add(diagnostic));

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

252=> descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.CompilationEnd);

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

30if (info.CandidateSymbols.Contains(null!))

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

39if (_symbolKindsThatCanBeOverridden.Contains(symbol.Kind) && DoesSymbolImplementAnotherSymbol(symbol))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (1)

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.cs (1)

46return type is INamedTypeSymbol { TypeKind: TypeKind.Interface } namedType && !allInterfaces.Contains(namedType)

Microsoft.CodeAnalysis.CodeStyle.Fixes (9)

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (2)

111if (TooManyArgumentsDiagnosticIds.Contains(diagnostic.Id)) 116if (CannotConvertDiagnosticIds.Contains(diagnostic.Id))

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)

109if (!ContainingType.Interfaces.Contains(TypeToGenerateIn))

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceService.cs (1)

307t => t.GetAllInterfacesIncludingThis().Contains(firstInterfaceType),

src\roslyn\src\Analyzers\Core\CodeFixes\UseCoalesceExpression\UseCoalesceExpressionForNullableTernaryConditionalCheckCodeFixProvider.cs (1)

28=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

src\roslyn\src\Analyzers\Core\CodeFixes\UseCoalesceExpression\UseCoalesceExpressionForTernaryConditionalCheckCodeFixProvider.cs (1)

29=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

src\roslyn\src\Analyzers\Core\CodeFixes\UseCollectionExpression\AbstractUseCollectionExpressionCodeFixProvider.cs (1)

30if (diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

46=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

173=> this.SupportedLanguagesArray.Contains(languageName);

Microsoft.CodeAnalysis.CSharp (43)

Binder\Binder_Expressions.cs (2)

2028(currentType.IsInterface && (declaringType.IsObjectType() || currentType.AllInterfacesNoUseSiteDiagnostics.Contains(declaringType)))) 2383(currentType.IsInterface && (declaringType.IsObjectType() || currentType.AllInterfacesNoUseSiteDiagnostics.Contains(declaringType))))

Binder\Binder_Lookup.cs (1)

1264return baseType.IsInterface && GetBaseInterfaces(derivedType, basesBeingResolved, ref useSiteInfo).Contains(baseType);

Binder\LocalScopeBinder.cs (2)

510declaredInThisScope |= newSymbolKind == SymbolKind.Local && this.Locals.Contains((LocalSymbol)newSymbol); 511declaredInThisScope |= newSymbolKind == SymbolKind.Method && this.LocalFunctions.Contains((LocalFunctionSymbol)newSymbol);

Binder\PatternExplainer.cs (1)

47Debug.Assert(!nodes.Contains(x));

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

1658if (currentType.IsInterfaceType() && type.IsInterfaceType() && currentType.AllInterfacesWithDefinitionUseSiteDiagnostics(ref useSiteInfo).Contains((NamedTypeSymbol)type)) 2730if (argsToParamsOpt.IsDefaultOrEmpty || !argsToParamsOpt.Contains(declaredParameterCount - 1))

BoundTree\Constructors.cs (1)

241if (!result.IsDefaultOrEmpty && result.Contains(RefKind.RefReadOnlyParameter))

CodeGen\EmitAddress.cs (1)

358if (topSequence.Locals.Contains(symbol))

Compilation\CSharpCompilation.cs (4)

1092if (!externalSyntaxTrees.Contains(oldTree)) 1104if (externalSyntaxTrees.Contains(newTree)) 1590if (referenceManager.AliasesOfReferencedAssemblies[i].Contains(aliasName)) 3708if ((emittingPdb || moduleBeingBuilt.EmitOptions.InstrumentationKinds.Contains(InstrumentationKind.TestCoverage)) &&

Compilation\CSharpSemanticModel.cs (5)

3686Debug.Assert(boundObjectCreation.ConstructorsGroup.Contains(boundObjectCreation.Constructor)); 4069if ((object)constructorOpt == null ? !candidateConstructors.Any() : !candidateConstructors.Contains(constructorOpt)) 4084Debug.Assert(candidateConstructors.Contains(constructorOpt)); 4359symbols = OneOrMany.Create(((BoundBadExpression)boundNodeForSyntacticParent).Symbols.WhereAsArray((sym, myMethodGroup) => myMethodGroup.Contains(sym), myMethodGroup)); 4460symbols = OneOrMany.Create(((BoundBadExpression)boundNodeForSyntacticParent).Symbols.WhereAsArray((sym, myPropertyGroup) => myPropertyGroup.Contains(sym), myPropertyGroup));

Compiler\MethodCompiler.cs (8)

FlowAnalysis\NullableWalker.cs (1)

811if ((symbol.IsRequired() || membersWithStateEnforcedByRequiredMembers.Contains(symbol.Name)) && constructor.ShouldCheckRequiredMembers())

FlowAnalysis\NullableWalker.DebugVerifier.cs (2)

73else if (overrideSkippedExpression || !s_skippedExpressions.Contains(expression.Kind)) 176if (!s_skippedExpressions.Contains(child.Kind))

Lowering\AsyncRewriter\AsyncRewriter.cs (1)

145if (instrumentations.Kinds.Contains(InstrumentationKindExtensions.LocalStateTracing))

Lowering\IteratorRewriter\IteratorRewriter.cs (1)

180if (instrumentations.Kinds.Contains(InstrumentationKindExtensions.LocalStateTracing))

Lowering\LocalRewriter\LocalRewriter.cs (4)

113if (instrumentation.Kinds.Contains(InstrumentationKindExtensions.LocalStateTracing) && 120if (instrumentation.Kinds.Contains(InstrumentationKind.TestCoverage) && 127if (instrumentation.Kinds.Contains(InstrumentationKind.StackOverflowProbing) && 134if (instrumentation.Kinds.Contains(InstrumentationKind.ModuleCancellation) &&

Lowering\SyntheticBoundNodeFactory.cs (2)

897if (!result.IsDefaultOrEmpty && (result.Contains(RefKind.RefReadOnlyParameter) || 898(useStrictArgumentRefKinds && result.Contains(RefKind.In))))

Parser\DirectiveParser.cs (1)

921return this.Options.PreprocessorSymbols.Contains(id);

Symbols\Compilation_UsedAssemblies.cs (1)

192Debug.Assert(retargetingAssembly.Modules[0].ReferencedAssemblySymbols.Contains(underlyingDependency));

Symbols\Source\SourceMemberContainerSymbol.cs (1)

2639Debug.Assert(newMembers.All(static (m, membersUnordered) => membersUnordered.Contains(m), membersUnordered));

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (1)

1975return (object)baseType == null || !baseType.AllInterfacesNoUseSiteDiagnostics.Contains(@interface);

Syntax\CSharpSyntaxTree.cs (1)

194return this.Options.PreprocessorSymbols.Contains(symbolName);

Microsoft.CodeAnalysis.CSharp.CodeStyle (16)

src\roslyn\src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (2)

46if (dataFlow.DataFlowsIn.Contains(symbol)) 71if (!beforeSwitch.WrittenInside.Contains(symbol))

src\roslyn\src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (3)

202if (dataFlow.ReadOutside.Contains(outLocalSymbol) || dataFlow.WrittenOutside.Contains(outLocalSymbol)) 272return dataFlow.DataFlowsIn.Contains(outLocalSymbol);

src\roslyn\src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (2)

292if (analysis == null || analysis.ReadOutside.Contains(localSymbol) || analysis.WrittenOutside.Contains(localSymbol))

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

123if (dataFlow != null && !dataFlow.DefinitelyAssignedOnEntry.Contains(exprSymbol))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseExpressionBody\UseExpressionBodyDiagnosticAnalyzer.cs (2)

56if (UseExpressionBodyForAccessorsHelper.Instance.SyntaxKinds.Contains(nodeKind)) 77if (helper.SyntaxKinds.Contains(nodeKind))

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (4)

182if (dataFlow.DataFlowsIn.Contains(_localSymbol)) 194if (dataFlow.AlwaysAssigned.Contains(_localSymbol)) 401return _semanticModel.AnalyzeDataFlow(statementOrExpression).DataFlowsIn.Contains(_localSymbol); 418return dataFlow.DataFlowsIn.Contains(_localSymbol);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (1)

127if (!conditionalDirectives.Contains((DirectiveTriviaSyntax)closeBraceDirective.GetStructure()!))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

86if (symbol.Locations.Contains(location))

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

src\roslyn\src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

121p => !dataFlow.DefinitelyAssignedOnExit.Contains(p));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseThrowExpression\UseThrowExpressionCodeFixProvider.cs (1)

31=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

Microsoft.CodeAnalysis.CSharp.Features (33)

ChangeSignature\ChangeSignatureFormattingRule.cs (2)

32if (s_allowableKinds.Contains(node.Kind())) 54if (previousToken.Kind() == SyntaxKind.CommaToken && s_allowableKinds.Contains(previousToken.Parent.Kind()))

ChangeSignature\CSharpChangeSignatureService.cs (3)

205if (matchKinds.Contains(current.Kind())) 239if (_updatableNodeKinds.Contains(node.Kind())) 245var matchingNode = node.AncestorsAndSelf().FirstOrDefault(n => _updatableAncestorKinds.Contains(n.Kind()));

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

89refKind: dataFlow.WrittenInside.Contains(capture) ? RefKind.Ref : RefKind.None,

Diagnostics\Analyzers\CSharpSimplifyTypeNamesDiagnosticAnalyzer.cs (1)

79=> node != null && s_kindsOfInterest.Contains(node.Kind());

ImplementInterface\CSharpImplementImplicitlyCodeRefactoringProvider.cs (1)

41return memberInterfaceImplementations.Any(static (impl, containingTypeInterfaces) => containingTypeInterfaces.Contains(impl.ContainingType), containingTypeInterfaces);

SignatureHelp\AttributeSignatureHelpProvider.cs (1)

60TriggerCharacters.Contains(token.ValueText[0]) &&

SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (3)

281s_triggerCharacters.Contains(token.ValueText[0]) && 330s_triggerCharacters.Contains(token.ValueText[0]) && 365s_triggerCharacters.Contains(token.ValueText[0]) &&

SignatureHelp\GenericNameFullyWrittenSignatureHelpProvider.cs (1)

46TriggerCharacters.Contains(token.ValueText[0]) &&

SignatureHelp\InitializerExpressionSignatureHelpProvider.cs (1)

49TriggerCharacters.Contains(token.ValueText[0]) &&

SignatureHelp\SignatureHelpUtilities.cs (1)

138triggerCharacters.Contains(token.ValueText[0]) &&

src\roslyn\src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (2)

46if (dataFlow.DataFlowsIn.Contains(symbol)) 71if (!beforeSwitch.WrittenInside.Contains(symbol))

src\roslyn\src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (3)

202if (dataFlow.ReadOutside.Contains(outLocalSymbol) || dataFlow.WrittenOutside.Contains(outLocalSymbol)) 272return dataFlow.DataFlowsIn.Contains(outLocalSymbol);

src\roslyn\src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (2)

292if (analysis == null || analysis.ReadOutside.Contains(localSymbol) || analysis.WrittenOutside.Contains(localSymbol))

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

123if (dataFlow != null && !dataFlow.DefinitelyAssignedOnEntry.Contains(exprSymbol))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseExpressionBody\UseExpressionBodyDiagnosticAnalyzer.cs (2)

56if (UseExpressionBodyForAccessorsHelper.Instance.SyntaxKinds.Contains(nodeKind)) 77if (helper.SyntaxKinds.Contains(nodeKind))

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (4)

src\roslyn\src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

121p => !dataFlow.DefinitelyAssignedOnExit.Contains(p));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseThrowExpression\UseThrowExpressionCodeFixProvider.cs (1)

31=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (2)

154if (helper.SyntaxKinds.Contains(current.Kind())) 219if (!helper.IsRelevantDeclarationNode(node) || !helper.SyntaxKinds.Contains(node.Kind()))

Microsoft.CodeAnalysis.CSharp.Workspaces (5)

FindSymbols\CSharpDeclaredSymbolInfoFactoryService.cs (1)

667simpleTypeName = typeParameterNames?.Contains(text) == true ? null : text;

Rename\CSharpRenameRewriterLanguageService.cs (2)

236_possibleNameConflicts.Contains(token.ValueText) || 906if (renamedSymbol.ContainingType != null && renamedSymbol.ContainingType.GetMembers(renamedSymbol.Name).Contains(renamedSymbol))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (1)

127if (!conditionalDirectives.Contains((DirectiveTriviaSyntax)closeBraceDirective.GetStructure()!))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

86if (symbol.Locations.Contains(location))

Microsoft.CodeAnalysis.Extensions.Package (8)

src\roslyn\src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

src\roslyn\src\Dependencies\Collections\OneOrMany.cs (1)

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

Symbols\ITypeSymbolExtensions.cs (1)

46return type is INamedTypeSymbol { TypeKind: TypeKind.Interface } namedType && !allInterfaces.Contains(namedType)

Microsoft.CodeAnalysis.Features (49)

AddImport\AbstractAddImportFeatureService.cs (1)

551.WhereAsArray(diagnostic => diagnosticIds.Contains(diagnostic.Id));

AddPackage\ParentInstallPackageCodeAction.cs (1)

96if (preferredVersion == null || !installedVersions.Contains(preferredVersion))

ChangeSignature\SignatureChange.cs (3)

68numParametersRemoved: originalListOfParameters.Count(p => !updatedListOfParameters.Contains(p)), 107var originalListWithoutRemovedOrAdded = originalListOfParameters.WhereAsArray(updatedListOfParameters.Contains); 108var updatedListWithoutRemovedOrAdded = updatedListOfParameters.WhereAsArray(originalListOfParameters.Contains);

CodeFixes\Service\CodeFixService.cs (2)

324if (collection.FixAllState is not null && collection.SupportedScopes.Contains(FixAllScope.Document)) 541hasFix: d => this.GetFixableDiagnosticIds(fixer, extensionManager).Contains(d.Id),

Common\AbstractProjectExtensionProvider.cs (1)

171if (languages.Contains(language))

Completion\CommonCompletionService.cs (2)

38=> item.Tags.Contains(WellKnownTags.Keyword); 41=> item.Tags.Contains(WellKnownTags.Snippet);

Completion\CompletionHelper.cs (1)

71=> item.Tags.Contains(WellKnownTags.Keyword);

Completion\CompletionItem.cs (1)

481if (Tags.Contains(tag))

Completion\Providers\SymbolCompletionItem.cs (3)

61if (!tags.Contains(WellKnownTags.Deprecated) && symbols.All(static symbol => symbol.IsObsolete())) 218if (supportedPlatforms != null && supportedPlatforms.InvalidProjects.Contains(document.Id.ProjectId)) 220var contextId = document.GetLinkedDocumentIds().FirstOrDefault(id => !supportedPlatforms.InvalidProjects.Contains(id.ProjectId));

Completion\SharedSyntaxContextsWithSpeculativeModel.cs (1)

35if (_document.Id != document.Id && !_lazyRelatedDocumentIds.Value.Contains(document.Id))

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

410return dataFlow.WrittenInside.Contains(foreachVariable);

Diagnostics\Service\DocumentAnalysisExecutor.cs (3)

79Contract.ThrowIfFalse(AnalysisScope.Analyzers.Contains(analyzer)); 187Contract.ThrowIfFalse(_compilationBasedAnalyzersInAnalysisScope.Contains(analyzer)); 207RoslynDebug.Assert(_compilationBasedAnalyzersInAnalysisScope.Contains(analyzer));

EditAndContinue\EditSession.cs (1)

1664var isMethodUpdated = updatedMethodTokens.Contains(methodId.Token);

EmbeddedLanguages\Classification\AbstractFallbackEmbeddedLanguageClassifier.cs (1)

35if (!_supportedKinds.Contains(token.RawKind))

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingWorkItem.cs (1)

47=> SpecificAnalyzers?.Count > 0 ? SpecificAnalyzers.Where(allAnalyzers.Contains) : allAnalyzers;

ExtractClass\ExtractClassWithDialogCodeAction.cs (1)

174var memberAnalysisForDocumentSymbols = remainingResults.Where(analysis => symbols.Contains(analysis.Member));

ExtractInterface\AbstractExtractInterfaceService.cs (1)

264var defaultInterfaceName = NameGenerator.GenerateUniqueName(candidateInterfaceName, name => !conflictingTypeNames.Contains(name));

FullyQualify\AbstractFullyQualifyService.cs (1)

145s => !currentSymbolInfo.CandidateSymbols.Contains(s));

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (1)

149return !containingType.AllInterfaces.Contains(constructedType);

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (2)

93.Where(i => typeParameters.Contains(_selectedType.TypeParameters[i])) 432!selectedMembers.Contains(symbol))

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

85Debug.Assert(priorityDocuments.All(d => projects.Contains(d.Project)));

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (1)

163Debug.Assert(priorityDocuments.All(d => projects.Contains(d.Project)));

Options\EditorConfig\EditorConfigFileGenerator.cs (1)

43if (!options.Contains(NamingStyleOptions.NamingPreferences))

Shared\Utilities\SupportedPlatformData.cs (1)

33var text = string.Format(FeaturesResources._0_1, project.Name, Supported(!InvalidProjects.Contains(project.Id)));

SignatureHelp\CommonSignatureHelpUtilities.cs (1)

181if (!parentType.AllInterfaces.Contains(ienumerableType))

src\roslyn\src\Analyzers\Core\Analyzers\Helpers\DeserializationConstructorCheck.cs (1)

21methodSymbol.ContainingType.AllInterfaces.Contains(_iSerializableType);

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

1052if (_iNotifyCompletionType != null && memberSymbol.ContainingType.AllInterfaces.Contains(_iNotifyCompletionType) && memberSymbol.Name == "IsCompleted")

src\roslyn\src\Analyzers\Core\Analyzers\UseAutoProperty\AccessedFields.cs (1)

33=> Equals(TrivialField, field) || NonTrivialFields.Contains(field);

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerDiagnosticAnalyzer.cs (1)

149if (objectType.Type == null || !objectType.Type.AllInterfaces.Contains(ienumerableType))

src\roslyn\src\Analyzers\Core\Analyzers\UseThrowExpression\AbstractUseThrowExpressionDiagnosticAnalyzer.cs (4)

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (2)

111if (TooManyArgumentsDiagnosticIds.Contains(diagnostic.Id)) 116if (CannotConvertDiagnosticIds.Contains(diagnostic.Id))

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)

109if (!ContainingType.Interfaces.Contains(TypeToGenerateIn))

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceService.cs (1)

307t => t.GetAllInterfacesIncludingThis().Contains(firstInterfaceType),

src\roslyn\src\Analyzers\Core\CodeFixes\UseCoalesceExpression\UseCoalesceExpressionForNullableTernaryConditionalCheckCodeFixProvider.cs (1)

28=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

src\roslyn\src\Analyzers\Core\CodeFixes\UseCoalesceExpression\UseCoalesceExpressionForTernaryConditionalCheckCodeFixProvider.cs (1)

29=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

src\roslyn\src\Analyzers\Core\CodeFixes\UseCollectionExpression\AbstractUseCollectionExpressionCodeFixProvider.cs (1)

30if (diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary))

Microsoft.CodeAnalysis.Razor.Compiler (2)

CSharp\ComponentDetectionConventions.cs (1)

25symbol.AllInterfaces.Contains(icomponentSymbol);

Language\Extensions\INamedTypeSymbolExtensions.cs (1)

15symbol.AllInterfaces.Contains(iTagHelperType);

Microsoft.CodeAnalysis.ResxSourceGenerator (24)

src\roslyn\src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

src\roslyn\src\Dependencies\Collections\OneOrMany.cs (1)

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

177} while (ancestor != null && !ancestorKinds.Contains(ancestor.Kind));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

140(SymbolEqualityComparer.Default.Equals(type, interfaceType) || type.AllInterfaces.Contains(interfaceType));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxToken.cs (1)

54=> Diagnostics.Contains(diagnostic) ? this : With(diagnostics: this.Diagnostics.Add(diagnostic));

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

252=> descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.CompilationEnd);

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

30if (info.CandidateSymbols.Contains(null!))

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

39if (_symbolKindsThatCanBeOverridden.Contains(symbol.Kind) && DoesSymbolImplementAnotherSymbol(symbol))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (1)

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.cs (1)

46return type is INamedTypeSymbol { TypeKind: TypeKind.Interface } namedType && !allInterfaces.Contains(namedType)

Microsoft.CodeAnalysis.Scripting (2)

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

191if (!architectureFilter.Contains(assemblyArchitecture))

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

124!architectureFilter.Contains(gacAssemblyName.ProcessorArchitecture))

Microsoft.CodeAnalysis.VisualBasic (10)

BoundTree\BoundConvertedTupleElements.vb (2)

16Debug.Assert(Not ElementPlaceholders.Contains(Nothing)) 17Debug.Assert(Not ConvertedElements.Contains(Nothing))

Compilation\MethodCompiler.vb (1)

113If _emittingPdb OrElse instrumentations.Kinds.Contains(InstrumentationKind.TestCoverage) Then

Compilation\VisualBasicCompilation.vb (2)

1793Debug.Assert(AllSyntaxTrees.Contains(tree)) 2248If Not SyntaxTrees.Contains(tree) Then

Lowering\Rewriter.vb (1)

52If(Not isBodySynthesized AndAlso instrumentations.Kinds.Contains(InstrumentationKind.TestCoverage),

Symbols\Source\ImplementsHelper.vb (1)

43Debug.Assert(GetExplicitInterfaceImplementations(sourceSym).Contains(implementedSym))

Symbols\Source\SourceMethodSymbol.vb (1)

1153Debug.Assert(ExplicitInterfaceImplementations.Contains(implementedMethod))

Symbols\Source\SourceModuleSymbol.vb (1)

173ElseIf _assemblySymbol.DeclaringCompilation.AllSyntaxTrees.Contains(tree) Then

Symbols\Source\SourcePropertySymbol.vb (1)

1050Debug.Assert(ExplicitInterfaceImplementations.Contains(implementedProperty))

Microsoft.CodeAnalysis.VisualBasic.CodeStyle (2)

src\roslyn\src\Analyzers\VisualBasic\Analyzers\UseAutoProperty\VisualBasicUseAutoPropertyAnalyzer.vb (1)

128If setMethod.Parameters.Contains(TryCast(symbol, IParameterSymbol)) Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Helpers\RemoveUnnecessaryImports\VisualBasicUnnecessaryImportsProvider.vb (1)

145If compilation.MemberImports.Contains(namespaceOrType) AndAlso

Microsoft.CodeAnalysis.VisualBasic.Features (9)

ChangeSignature\VisualBasicChangeSignatureService.vb (5)

160If _declarationKinds.Contains(current.Kind()) Then 164If _declarationAndInvocableKinds.Contains(current.Kind()) Then 230If _updatableNodeKinds.Contains(node.Kind()) Then 234Dim matchingNode = node.AncestorsAndSelf().FirstOrDefault(Function(a) _updatableAncestorKinds.Contains(a.Kind())) 262If _nodeKindsToIgnore.Contains(matchingNode.Kind()) Then

Completion\VisualBasicCompletionService.vb (1)

97If keywordCompletionItem IsNot Nothing AndAlso keywordCompletionItem.Tags.Contains(WellKnownTags.Intrinsic) Then

Diagnostics\Analyzers\VisualBasicSimplifyTypeNamesDiagnosticAnalyzer.vb (1)

66Return s_kindsOfInterest.Contains(node.Kind)

SignatureHelp\CollectionInitializerSignatureHelpProvider.vb (1)

37TriggerCharacters.Contains(token.ValueText(0)) AndAlso

src\roslyn\src\Analyzers\VisualBasic\Analyzers\UseAutoProperty\VisualBasicUseAutoPropertyAnalyzer.vb (1)

128If setMethod.Parameters.Contains(TryCast(symbol, IParameterSymbol)) Then

Microsoft.CodeAnalysis.VisualBasic.Workspaces (3)

FindSymbols\VisualBasicDeclaredSymbolInfoFactoryService.vb (1)

553simpleTypeName = If(typeParameterNames?.Contains(text), Nothing, text)

Rename\VisualBasicRenameRewriterLanguageService.vb (1)

793If renamedSymbol.ContainingType IsNot Nothing AndAlso renamedSymbol.ContainingType.GetMembers(renamedSymbol.Name).Contains(renamedSymbol) Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Helpers\RemoveUnnecessaryImports\VisualBasicUnnecessaryImportsProvider.vb (1)

145If compilation.MemberImports.Contains(namespaceOrType) AndAlso

Microsoft.CodeAnalysis.Workspaces (51)

Classification\ClassifierHelper.cs (3)

106if (ClassificationTypeNames.AdditiveTypeNames.Contains(span.ClassificationType)) 174ClassificationTypeNames.AdditiveTypeNames.Contains(span.ClassificationType) || ClassificationTypeNames.AdditiveTypeNames.Contains(previousSpan.ClassificationType);

CodeActions\CodeAction.cs (1)

102if (priority == CodeActionPriority.High && !this.CustomTags.Contains(CanBeHighPriorityTag))

CodeActions\CodeActionRequestPriority.cs (1)

69if (priority == CodeActionRequestPriority.High && !customTags.Contains(CodeAction.CanBeHighPriorityTag))

CodeFixes\FixAllOccurrences\FixAllProvider.cs (1)

92if (supportedFixAllScopes.Contains(FixAllScope.Custom))

CodeFixesAndRefactorings\FixAllProviderInfo.cs (1)

106=> supportedDiagnosticIds.Contains(diagnostic.Id);

CodeRefactorings\FixAllOccurences\RefactorAllProvider.cs (1)

91if (supportedRefactorAllScopes.Contains(RefactorAllScope.Custom))

Diagnostics\DiagnosticData.cs (1)

394=> CustomTags.Contains(WellKnownDiagnosticCustomTags.DoesNotSupportF1Help) ? null : Id;

Diagnostics\Extensions.cs (1)

321diagnosticIdsToFilter.Contains(diagnostic.Id) ||

FindSymbols\FindReferences\Finders\PropertyAccessorSymbolReferenceFinder.cs (1)

94if (accessors.Contains(data.symbol))

FindSymbols\FindReferences\Finders\PropertySymbolReferenceFinder.cs (1)

90if (containingTypeSyntaxes.Contains(constructorSyntax))

FindSymbols\FindReferences\FindReferencesSearchEngine.cs (2)

141if (!projectsToSearch.Contains(currentProject)) 188Contract.ThrowIfFalse(linkedSymbols.Contains(symbol), "Linked symbols did not contain the very symbol we started with.");

ReassignedVariable\AbstractReassignedVariableService.cs (1)

381if (analysis.DefinitelyAssignedOnEntry.Contains(localOrParameter))

Recommendations\AbstractRecommendationService.cs (2)

129if (this.GetOuterTypesAndBases().Contains(containingTypeOriginalDefinition)) 131return this.GetEnclosingTypeBases().Contains(containingTypeOriginalDefinition);

Recommendations\AbstractRecommendationServiceRunner.cs (1)

398.WhereAsArray(static (s, staticMembers) => s is { IsStatic: true, ContainingType.IsExtension: true } && !staticMembers.Contains(s), staticMembers);

Rename\Renamer.RenameDocumentActionSet.cs (1)

80if (actions.Any(static (a, self) => !self.ApplicableActions.Contains(a), this))

src\roslyn\src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

src\roslyn\src\Dependencies\Collections\OneOrMany.cs (1)

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxToken.cs (1)

54=> Diagnostics.Contains(diagnostic) ? this : With(diagnostics: this.Diagnostics.Add(diagnostic));

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

252=> descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.CompilationEnd);

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

30if (info.CandidateSymbols.Contains(null!))

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

39if (_symbolKindsThatCanBeOverridden.Contains(symbol.Kind) && DoesSymbolImplementAnotherSymbol(symbol))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (1)

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.cs (1)

46return type is INamedTypeSymbol { TypeKind: TypeKind.Interface } namedType && !allInterfaces.Contains(namedType)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

46=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

173=> this.SupportedLanguagesArray.Contains(languageName);

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

122return DefaultAssemblyNames.Contains(name);

Workspace\Host\PersistentStorage\IPersistentStorageConfiguration.cs (1)

95val = new string([.. val.Where(c => !s_invalidPathChars.Contains(c))]);

Workspace\ProjectSystem\ProjectSystemProject.cs (1)

1245return _allMetadataReferences.TryGetValue(fullPath, out var propertiesList) && propertiesList.Contains(properties);

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (1)

784if (!projectReferenceInformation.OutputPaths.Contains(outputPath))

Workspace\Solution\Solution_SemanticModelCaching.cs (3)

31if (localArray.Contains((documentId, semanticModel))) 39tuple => !relatedDocumentIds.Contains(tuple.documentId)); 42if (relatedDocumentIds.Contains(documentId))

Workspace\Solution\SolutionCompilationState.cs (1)

252if (arg.changedProjectIds.Contains(id))

Microsoft.DotNet.HotReload.Watch (1)

HotReload\CompilationHandler.cs (1)

95_previousUpdates = _previousUpdates.RemoveAll(update => projectsToBeRebuilt.Contains(update.ProjectId));

Microsoft.Interop.ComInterfaceGenerator (1)

Analyzers\GeneratedComInterfaceAttributeAnalyzer.cs (1)

73return SupportedComInterfaceTypes.Contains(interfaceType);

Microsoft.TestPlatform.TestHostRuntimeProvider (1)

Hosting\DefaultTestHostManager.cs (1)

277var isSupportedTargetFramework = SupportedTargetFrameworks.Contains(targetFrameworkMoniker);

NuGet.Commands (2)

RestoreCommand\Diagnostics\UnexpectedDependencyMessages.cs (1)

324.Where(e => e.Dependencies.Contains(dependency))

RestoreCommand\Utility\MSBuildRestoreUtility.cs (1)

691if (!frameworkInfo.DownloadDependencies.Contains(dependency))

Roslyn.Diagnostics.Analyzers (28)

src\roslyn\src\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

src\roslyn\src\Dependencies\Collections\OneOrMany.cs (1)

112=> HasOneItem ? EqualityComparer<T>.Default.Equals(item, _one) : _many.Contains(item);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

177} while (ancestor != null && !ancestorKinds.Contains(ancestor.Kind));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (1)

140(SymbolEqualityComparer.Default.Equals(type, interfaceType) || type.AllInterfaces.Contains(interfaceType));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\Common\EmbeddedSyntaxToken.cs (1)

54=> Diagnostics.Contains(diagnostic) ? this : With(diagnostics: this.Diagnostics.Add(diagnostic));

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

252=> descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.CompilationEnd);

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

30if (info.CandidateSymbols.Contains(null!))

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

39if (_symbolKindsThatCanBeOverridden.Contains(symbol.Kind) && DoesSymbolImplementAnotherSymbol(symbol))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (1)

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.cs (1)

46return type is INamedTypeSymbol { TypeKind: TypeKind.Interface } namedType && !allInterfaces.Contains(namedType)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

46=> !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Mef\MefWorkspaceServices.cs (1)

173=> this.SupportedLanguagesArray.Contains(languageName);

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (2)

142if (namedType.AllInterfaces.Contains(_symbolType)) 158namedType.AllInterfaces.Contains(_symbolType) &&

Roslyn.Diagnostics.CSharp.Analyzers (2)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (1)

127if (!conditionalDirectives.Contains((DirectiveTriviaSyntax)closeBraceDirective.GetStructure()!))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

86if (symbol.Locations.Contains(location))

Roslyn.Diagnostics.VisualBasic.Analyzers (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SemanticFacts\VisualBasicSemanticFacts.vb (1)

79If symbol.Locations.Contains(location) Then

System.Collections.Immutable (1)

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

1230return self.Contains((T)value!);