Contains

Options\SymbolNamesWithValueOptionTests.cs (1)

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

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

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

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

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

Resources\RoslynTestUtils.cs (2)

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

Resources\RoslynTestUtils.cs (2)

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

RouteEmbeddedLanguage\RoutePatternBraceMatcherTests.cs (2)

200if (!spans.Contains(result.Value.LeftSpan) || !spans.Contains(result.Value.RightSpan))

Compilation\Compilation.cs (1)

3308emitOptions.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)

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

DiagnosticAnalyzer\AnalyzerExecutor.cs (2)

299static (d, supportedSuppressions) => supportedSuppressions.Contains(d), 402if (symbolAction.Kinds.Contains(symbol.Kind))

DiagnosticAnalyzer\CompilationWithAnalyzers.cs (3)

156if (!_analyzers.Contains(analyzer)) 174if (analyzers.Any(static (a, self) => !self._analyzers.Contains(a), this)) 219if (!AdditionalFiles.Contains(file))

DiagnosticAnalyzer\DiagnosticAnalysisContext.cs (3)

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

DiagnosticAnalyzer\DiagnosticStartAnalysisScope.cs (1)

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

DiagnosticAnalyzer\SuppressMessageAttributeState.cs (1)

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

Emit\EditAndContinue\SymbolMatcher.cs (1)

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

Operations\ControlFlowGraphBuilder.cs (2)

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

Operations\ControlFlowGraphBuilder.InterpolatedStringContext.cs (1)

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

SourceGeneration\GeneratorDriver.cs (1)

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

SourceGeneration\SyntaxStore.cs (1)

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

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

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

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

216DataFlowAnalysisContext.AdditionalSupportedValueTypes.Contains(namedType))

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

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

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

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

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

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

Extensions\ImmutableArrayExtensions.cs (6)

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

OneOrMany.cs (1)

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

Binder\Binder_Expressions.cs (1)

2307(currentType.IsInterface && (declaringType.IsObjectType() || currentType.AllInterfacesNoUseSiteDiagnostics.Contains(declaringType))))

Binder\Binder_Lookup.cs (1)

1306return 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 (1)

2711if (argsToParamsOpt.IsDefaultOrEmpty || !argsToParamsOpt.Contains(declaredParameterCount - 1))

BoundTree\Constructors.cs (1)

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

CodeGen\EmitAddress.cs (1)

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

Compilation\CSharpSemanticModel.cs (3)

3678Debug.Assert(boundObjectCreation.ConstructorsGroup.Contains(boundObjectCreation.Constructor)); 4056if ((object)constructorOpt == null ? !candidateConstructors.Any() : !candidateConstructors.Contains(constructorOpt)) 4071Debug.Assert(candidateConstructors.Contains(constructorOpt));

Compiler\MethodCompiler.cs (1)

361if (_emittingPdb || instrumentation.Kinds.Contains(InstrumentationKind.TestCoverage))

FlowAnalysis\NullableWalker.cs (1)

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

FlowAnalysis\NullableWalker.DebugVerifier.cs (2)

73else if (overrideSkippedExpression || !s_skippedExpressions.Contains(expression.Kind)) 162if (!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)

876if (!result.IsDefaultOrEmpty && (result.Contains(RefKind.RefReadOnlyParameter) || 877(useStrictArgumentRefKinds && result.Contains(RefKind.In))))

Parser\DirectiveParser.cs (1)

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

Symbols\Compilation_UsedAssemblies.cs (1)

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

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (1)

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

Syntax\CSharpSyntaxTree.cs (1)

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

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

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

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

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

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

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

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

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

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (2)

401return _semanticModel.AnalyzeDataFlow(statementOrExpression).DataFlowsIn.Contains(_localSymbol); 418return dataFlow.DataFlowsIn.Contains(_localSymbol);

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

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

LanguageServer\CSharpLspBuildOnlyDiagnosticsTests.cs (1)

29if (!supported.Contains(errorCode) && errorCode > 0)

Diagnostics\DiagnosticAnalyzerTests.cs (1)

3715if (analyzersToQuery.Contains(analyzer))

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)

207if (matchKinds.Contains(current.Kind())) 241if (_updatableNodeKinds.Contains(node.Kind())) 247var matchingNode = node.AncestorsAndSelf().FirstOrDefault(n => _updatableAncestorKinds.Contains(n.Kind()));

Diagnostics\Analyzers\CSharpSimplifyTypeNamesDiagnosticAnalyzer.cs (1)

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

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

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

SignatureHelp\InitializerExpressionSignatureHelpProvider.cs (1)

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

SignatureHelp\SignatureHelpUtilities.cs (1)

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

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

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

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

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

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

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

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

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

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (2)

401return _semanticModel.AnalyzeDataFlow(statementOrExpression).DataFlowsIn.Contains(_localSymbol); 418return dataFlow.DataFlowsIn.Contains(_localSymbol);

UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (2)

152if (helper.SyntaxKinds.Contains(current.Kind())) 217if (!helper.IsRelevantDeclarationNode(node) || !helper.SyntaxKinds.Contains(node.Kind()))

Diagnostics\Suppression\RemoveUnnecessaryPragmaSuppressionsTests.cs (1)

159if (!supported.Contains(errorCode) && errorCode > 0)

Compilation\CompilationAPITests.cs (3)

804Assert.False(comp.SyntaxTrees.Contains(SyntaxFactory.ParseSyntaxTree(s1))); 837Assert.True(comp.SyntaxTrees.Contains(t1)); 1498Assert.False(comp.SyntaxTrees.Contains(null));

Compilation\UsedAssembliesTests.cs (2)

115var tryRemove = specificReferencesToAssert.Where(reference => reference.Properties.Kind == MetadataImageKind.Assembly && !used.Contains(reference)); 333var tryRemove = specificReferencesToAssert.Where(reference => reference.Properties.Kind == MetadataImageKind.Assembly && !used.Contains(reference));

CodeGen\WinRTCollectionTests.cs (2)

7434Assert.True(model.LookupSymbols(add.SpanStart, jsonObjType, "Add").Contains(addMethod)); 7435Assert.True(model.LookupSymbols(add.SpanStart, jsonObjType).Contains(addMethod));

FindSymbols\CSharpDeclaredSymbolInfoFactoryService.cs (1)

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

Rename\CSharpRenameRewriterLanguageService.cs (2)

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

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

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

BackgroundWorkIndicator\BackgroundWorkIndicatorContext.cs (1)

123Contract.ThrowIfFalse(_scopes_onlyAccessUnderLock.Contains(scope));

IntelliSense\AsyncCompletion\CommitManager.cs (3)

360if (rule.Characters.Contains(ch)) 368if (rule.Characters.Contains(ch)) 376return rule.Characters.Contains(ch);

IntelliSense\AsyncCompletion\Helpers.cs (3)

130if (rule.Characters.Contains(ch)) 138if (rule.Characters.Contains(ch)) 146return rule.Characters.Contains(ch);

IntelliSense\AsyncCompletion\ItemManager.CompletionListUpdater.cs (1)

980if (!_unselectedExpanders.Contains(itemFilter))

Tagging\AbstractAsynchronousTaggerProvider.TagSource.cs (2)

325_dataSource.Options.Contains(option) || _dataSource.FeatureOptions.Contains(option)));

Completion\TestFileSystemCompletionHelper.cs (1)

48=> _directories.Contains(fullPath.TrimEnd(PathUtilities.DirectorySeparatorChar));

SymbolFinder\SymbolFinderTests.cs (6)

499Assert.True(immediateDerived.All(d => d.Interfaces.Contains(rootType))); 507Assert.True(transitiveDerived.All(d => d.AllInterfaces.Contains(rootType)), "All results must transitively derive from the type"); 508Assert.True(transitiveDerived.Any(d => !d.Interfaces.Contains(rootType)), "At least one result must not immediately derive from the type"); 549Assert.True(immediateImpls.All(d => d.Interfaces.Contains(rootType))); 559Assert.True(transitiveImpls.All(d => d.AllInterfaces.Contains(rootType)), "All results must transitively derive from the type"); 560Assert.True(transitiveImpls.Any(d => !d.Interfaces.Contains(rootType)), "At least one result must not immediately derive from the type");

Workspaces\ClassificationTypeNamesTests.cs (1)

42=> Assert.True(ClassificationTypeNames.AllTypeNames.Contains(fieldName), $"Missing token type {fieldName}.");

Diagnostics\AdditionalFileDiagnosticsTests.vb (1)

93If namedType.AllInterfaces.Contains(context.Compilation.GetTypeByMetadataName("System.Runtime.Serialization.ISerializable")) Then

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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)

ChangeSignature\SignatureChange.cs (3)

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

CodeFixes\Service\CodeFixService.cs (1)

327if (collection.FixAllState is not null && collection.SupportedScopes.Contains(FixAllScope.Document))

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)

60if (!tags.Contains(WellKnownTags.Deprecated) && symbols.All(static symbol => symbol.IsObsolete())) 211if (supportedPlatforms != null && supportedPlatforms.InvalidProjects.Contains(document.Id.ProjectId)) 213var 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 (6)

143var compilation = _compilationBasedProjectAnalyzersInAnalysisScope.Contains(analyzer) ? _compilationWithAnalyzers.ProjectCompilation : _compilationWithAnalyzers.HostCompilation; 173RoslynDebug.Assert(_compilationBasedProjectAnalyzersInAnalysisScope.Contains(analyzer) || _compilationBasedHostAnalyzersInAnalysisScope.Contains(analyzer)); 176var analysisScope = _compilationBasedProjectAnalyzersInAnalysisScope.Contains(analyzer) 197RoslynDebug.Assert(_compilationBasedProjectAnalyzersInAnalysisScope.Contains(analyzer) || _compilationBasedHostAnalyzersInAnalysisScope.Contains(analyzer));

EditAndContinue\EditSession.cs (1)

1331var 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;

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (1)

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

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (1)

90.Where(i => typeParameters.Contains(_selectedType.TypeParameters[i]))

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (1)

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

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

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

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

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

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

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

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

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

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\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (2)

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

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

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

Handler\CodeActions\CodeActionHelpers.cs (1)

Handler\SemanticTokens\SemanticTokensSchema.cs (2)

62.Where(classificationTypeName => !ClassificationTypeNames.AdditiveTypeNames.Contains(classificationTypeName)) 73.Where(classificationTypeName => !ClassificationTypeNames.AdditiveTypeNames.Contains(classificationTypeName))

Handler\SpellCheck\WorkspaceSpellCheckHandler.cs (1)

66if (!supportedLanguages.Contains(project.Language))

Workspaces\LspWorkspaceManager.cs (1)

577return _manager._lspWorkspaceRegistrationService.GetAllRegistrations().Contains(workspace);

SemanticTokens\SemanticTokensRangeTests.cs (1)

597var expectedNames = ClassificationTypeNames.AllTypeNames.Where(s => !ClassificationTypeNames.AdditiveTypeNames.Contains(s));

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

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

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

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

DeclarePublicApiAnalyzer.Impl.cs (1)

790if (s_ignorableMethodKinds.Contains(methodSymbol.MethodKind))

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

Services\ProcessTelemetry\RemoteProcessTelemetryService.cs (1)

94if (loggerTypes.Contains(typeof(T).Name))

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

191if (!architectureFilter.Contains(assemblyArchitecture))

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

124!architectureFilter.Contains(gacAssemblyName.ProcessorArchitecture))

Compilation\ControlFlowGraphVerifier.cs (5)

780AssertTrueWithGraph(block.EnclosingRegion.CaptureIds.Contains(id), $"Flow capture initialization [{id}] should come from the containing region.", finalGraph); 796if (block.EnclosingRegion.CaptureIds.Contains(id) || longLivedIds.Contains(id)) 801if (block.EnclosingRegion.EnclosingRegion.CaptureIds.Contains(id)) 813else if (block.EnclosingRegion.EnclosingRegion?.EnclosingRegion.CaptureIds.Contains(id) ?? false) 1027if (region.CaptureIds.Contains(id))

Diagnostics\CouldHaveMoreSpecificTypeAnalyzer.cs (1)

213if (derivedType.Interfaces.Contains(baseType))

TargetFrameworkUtil.cs (1)

352if (references.Contains(r))

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

Diagnostics\SuppressMessageTargetSymbolResolverTests.cs (1)

1403where candidate != null && candidate.Locations.Contains(location)

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)

1792Debug.Assert(AllSyntaxTrees.Contains(tree)) 2247If 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))

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

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

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

145If compilation.MemberImports.Contains(namespaceOrType) AndAlso

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\Analyzers\VisualBasic\Analyzers\UseAutoProperty\VisualBasicUseAutoPropertyAnalyzer.vb (1)

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

Compilation\CompilationAPITests.vb (1)

1312Assert.False(comp.SyntaxTrees.Contains(Nothing))

UsedAssembliesTests.vb (2)

101Dim tryRemove = specificReferencesToAssert.Where(Function(reference) reference.Properties.Kind = MetadataImageKind.Assembly AndAlso Not used.Contains(reference)) 157Dim tryRemove = specificReferencesToAssert.Where(Function(reference) reference.Properties.Kind = MetadataImageKind.Assembly AndAlso Not used.Contains(reference))

FindSymbols\VisualBasicDeclaredSymbolInfoFactoryService.vb (1)

547simpleTypeName = 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\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Helpers\RemoveUnnecessaryImports\VisualBasicUnnecessaryImportsProvider.vb (1)

145If compilation.MemberImports.Contains(namespaceOrType) AndAlso

Classification\ClassifierHelper.cs (3)

102if (ClassificationTypeNames.AdditiveTypeNames.Contains(span.ClassificationType)) 171ClassificationTypeNames.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))

CodeRefactorings\FixAllOccurences\FixAllProvider.cs (1)

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

Diagnostics\CompilationWithAnalyzersPair.cs (2)

55if (ProjectAnalyzers.Contains(analyzer)) 61Debug.Assert(HostAnalyzers.Contains(analyzer));

Diagnostics\DiagnosticData.cs (1)

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

Diagnostics\Extensions.cs (1)

316diagnosticIdsToFilter.Contains(diagnostic.Id) ||

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

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

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

90if (containingTypeSyntaxes.Contains(constructorSyntax))

FindSymbols\FindReferences\FindReferencesSearchEngine.cs (2)

140if (!projectsToSearch.Contains(currentProject)) 187Contract.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)

125if (this.GetOuterTypesAndBases().Contains(containingTypeOriginalDefinition)) 127return 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\Dependencies\Collections\Extensions\ImmutableArrayExtensions.cs (6)

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

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

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

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

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

120return DefaultAssemblyNames.Contains(name);

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

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

Workspace\ProjectSystem\ProjectSystemProject.cs (1)

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

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (1)

772if (!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)

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

VisualStudioMSBuildWorkspaceTests.cs (3)

198mr.Properties.Aliases.Contains(aliasName)); 1407Assert.DoesNotContain(metaRefs, r => r.Properties.Aliases.Contains("CSharpProject")); 1433Assert.DoesNotContain(vbProject.MetadataReferences, r => r.Properties.Aliases.Contains("CSharpProject"));

SolutionTests\TryApplyChangesTests.cs (1)

45return _allowedKinds.Contains(feature);

Analyzers\GeneratedComInterfaceAttributeAnalyzer.cs (1)

73return SupportedComInterfaceTypes.Contains(interfaceType);

CodeLens\CodeLensCallbackListener.cs (1)

72if (!projectGuids.Contains(projectGuid))

CommonControls\NewTypeDestinationSelectionViewModel.cs (1)

119if (_conflictingNames.Contains(trimmedName))

Diagnostics\VisualStudioVenusSpanMappingService.cs (1)

89if (documentIds.Contains(currentDocumentId))

Workspace\VisualStudioDocumentNavigationService.cs (1)

224var documentIdToNavigate = documentIdsForFilePath.Contains(documentId) ? documentId : documentIdsForFilePath.First();

Implementation\LanguageServer\Handler\Completion\CompletionHandler.cs (1)

142var commitCharacters = xamlCommitCharacters.Characters.Select(c => new VSInternalCommitCharacter { Character = c.ToString(), Insert = !xamlCommitCharacters.NonInsertCharacters.Contains(c) }).ToImmutableArray();

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

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

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

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

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

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

78If symbol.Locations.Contains(location) Then

OptionPages\PerformanceLoggersPage.cs (1)

98if (loggerTypeNames.Contains(typeof(T).Name))

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

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

1009return other.Contains(array[0]); 1011return other.Contains(array[0]) && other.Contains(array[1]); 1013return other.Contains(array[0]) && other.Contains(array[1]) && other.Contains(array[2]);

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

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

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

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

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

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

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

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

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

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (1)

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

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

94ApplicableAccessibilityList.Contains(GetAccessibility(symbol));

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

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

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

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

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

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