Contains

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\GlobalFlowStateAnalysis\GlobalFlowStateAnalysis.GlobalFlowStateAnalysisValueSetDomain.cs (1)

174if (candidateNodes.Contains(parent))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\TrackedEntitiesBuilder.cs (1)

63=> PointsToValues.Contains(value);

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

137if (!allEntities.Contains(analysisEntity)) 607if (analysisEntity != null && candidateEntitiesBuilder.Contains(analysisEntity))

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowAnalysis.cs (2)

253var isUnreachableBlock = unreachableBlocks.Contains(block.Ordinal); 366if (isUnreachableBlock && !unreachableBlocks.Contains(successorBlock.Ordinal))

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

641Debug.Assert(_visitedLambdas.Contains(lambda)); 2331Debug.Assert(arguments.All(arg => !_pendingArgumentsToReset.Contains(arg))); 2393Debug.Assert(arguments.All(_pendingArgumentsToReset.Contains));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

274if (!applicableAttributeNodes.Contains(node))

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

346if (set.Contains(method.Parameters[i]))

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\TemporarySet`1.cs (2)

68return storage.Contains(item); 77return storage.Contains(item);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

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

574var rule = !valueUsageInfo.IsWrittenTo() && !valueUsageInfo.IsNameOnly() && !symbolsReferencedInDocComments.Contains(member) 603!_propertiesWithShadowGetAccessorUsages.Contains(property);

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (2)

233if (!fieldNames.Contains(identifier.ValueText)) 511if (!fieldNames.Contains(syntaxFacts.GetIdentifierOfIdentifierName(identifierName).ValueText))

src\Analyzers\Core\Analyzers\UseConditionalExpression\ForAssignment\UseConditionalExpressionForAssignmentHelpers.cs (1)

149declaredPatternSymbols.Contains(local))

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

87public bool Contains(T value) => _set?.Contains(value) ?? false;

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

1403if (!set.Contains(item))

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

188if (set.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

61var captureKind = flowCaptureReference.Parent.IsAnyCompoundAssignment() || rvalueFlowCaptureIds.Contains(flowCaptureReference.Id) 76Debug.Assert(kind == FlowCaptureKind.LValueAndRValueCapture || !rvalueFlowCaptureIds.Contains(captureId), "Flow capture used as both an r-value and an l-value, but with incorrect flow capture kind");

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

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

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

165if (!set2.Contains(operation))

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

227if (write != null && operations.Contains(write))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\BottomUpBaseIndentationFinder.cs (1)

320if (map.Contains(operation.TextSpan))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.cs (5)

184_indentationMap.Contains(intervalTreeSpan)) 309if (!option.IsMaskOn(SuppressOption.NoSpacing) || _suppressSpacingMap.Contains(operation.TextSpan)) 336if (!option.IsOn(SuppressOption.DisableFormatting) || _suppressFormattingMap.Contains(operation.TextSpan)) 356if (!option.IsMaskOn(SuppressOption.NoWrapping) || _suppressWrappingMap.Contains(operation.TextSpan)) 380_anchorMap.Contains(operation.TextSpan) ||

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

106if (!referencedElements.Contains(namingStyle.ID))

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (2)

185if (alreadyCheckingTypes.Contains(constraint)) 206if (alreadyCheckingTypes.Contains(genericParam))

src\Analyzers\Core\CodeFixes\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (3)

97if (declarators.Contains(parentDeclaration)) 99Debug.Assert(childDeclarators.All(c => !declarators.Contains(c))); 106if (!declarators.Contains(childDeclarator))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

Extensions\ImmutableArrayExtensions.cs (1)

1403if (!set.Contains(item))

Binder\Binder_Attributes.cs (1)

498else if (boundNamedArgumentsSet!.Contains(argumentName))

Binder\Binder_Lookup.cs (1)

1035if (!conflictingMembers.Contains(sym))

Binder\Binder_Operators.cs (1)

2702if (isViable(method, parameterCount) && !existing.Contains(method.GetLeastOverriddenMethod(ContainingType)))

Binder\RefSafetyAnalysis.cs (1)

299RoslynDebug.Assert(_visited.Contains(expr), $"Expected {expr} `{expr.Syntax}` to be visited.");

CodeGen\CodeGenerator.cs (1)

203=> stackLocalsOpt?.Contains(local) ?? false;

Compiler\DocumentationCommentCompiler.cs (2)

418if (!documentedParameters.Contains(parameter)) 433if (!documentedTypeParameters.Contains(typeParameter))

FlowAnalysis\AlwaysAssignedWalker.cs (1)

136if (branch.Branch != null && RegionContains(branch.Branch.Syntax.Span) && !_labelsInside.Contains(branch.Label))

FlowAnalysis\DataFlowsOutWalker.cs (1)

266if (!_dataFlowsOut.Contains(parameter) && (node == null || node is ReturnStatementSyntax))

FlowAnalysis\DefiniteAssignment.cs (4)

1893if (slot > 0) SetSlotState(slot, initiallyAssignedVariables?.Contains(parameter) == true); 2321initiallyAssignedVariables?.Contains(symbol) == true; 2397if (initiallyAssignedVariables?.Contains(node.LocalSymbol) == true) 2562if (_unassignedVariableAddressOfSyntaxes?.Contains(node.Syntax as PrefixUnaryExpressionSyntax) == false)

FlowAnalysis\NullableWalker.DebugVerifier.cs (1)

48if (!verifier._visitedExpressions.Contains(analyzedNode))

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (2)

785return _awaitContainingCatches != null && _awaitContainingCatches.Contains(node); 959if (this.IsRoot() || (LabelsOpt != null && LabelsOpt.Contains(label)))

Lowering\ClosureConversion\ClosureConversion.Analysis.Tree.cs (1)

671Debug.Assert(_freeVariables.Contains(symbol));

Lowering\ClosureConversion\ClosureConversion.cs (1)

770if (_assignLocals == null || !_assignLocals.Contains(local))

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.IteratorFinallyFrame.cs (1)

101if (this.IsRoot() || (labels != null && labels.Contains(label)))

Lowering\LocalRewriter\DelegateCacheRewriter.cs (1)

211if (used.Contains(typeParameter))

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.cs (5)

461!loweredNodes.Contains(nodesToLower[indexOfNode + 2]) ? nodesToLower[indexOfNode + 2] : null; 500Debug.Assert(!loweredNodes.Contains(node)); 528Debug.Assert(!loweredNodes.Contains(test2)); 564if (loweredNodes.Contains(node)) 596!loweredNodes.Contains(p))

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (1)

426if ((object)s != null && !_localsInScope.Contains(s))

Lowering\SyntheticBoundNodeFactory.cs (1)

1127Debug.Assert(!labels.Contains(v2));

Symbols\BaseTypeAnalysis.cs (1)

84if (typesWithCycle.Contains(type.OriginalDefinition))

Symbols\Compilation_UsedAssemblies.cs (1)

54if (setOfReferences.Contains(reference))

Symbols\MemberSignatureComparer.cs (1)

731if (constraintTypes2.Contains(constraintType))

Symbols\Source\SourceAssemblySymbol.cs (2)

1255if (!uniqueAttributes.Contains(attribute)) 2755if (handledUnreadFields != null && handledUnreadFields.Contains(field))

Symbols\Symbol_Attributes.cs (1)

515if (!toRemove.Contains(d))

Symbols\Synthesized\SynthesizedBackingFieldSymbol.cs (1)

204if (!notAnnotatedDiagnosticsSet.Contains(diagnostic))

Symbols\TypeSymbolExtensions.cs (1)

1225(type, parameters, unused) => type.TypeKind == TypeKind.TypeParameter && parameters.Contains((TypeParameterSymbol)type);

Syntax\SyntaxNodeRemover.cs (1)

156return _nodesToRemove.Contains(node);

Utilities\FirstAmongEqualsSet.cs (1)

90if (!_hashSet.Contains(key))

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

91return rightmostName != null && fieldNames.Contains(rightmostName);

Diagnostics\GetDiagnosticsTests.cs (13)

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

104if (seenTypes.Contains(type))

Completion\CompletionProviders\SnippetCompletionProvider.cs (1)

177snippets = snippets.Where(snippet => !s_snippetsWithReplacements.Contains(snippet.Shortcut));

ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (2)

662queryExpressionProcessingInfo.IdentifierNames.Contains(identifierName.Identifier.ValueText)) 981=> IdentifierNames.Contains(identifier.ValueText);

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (2)

129if (declarationsToRemove.Contains(statementSyntax)) 162if (!declarationsToRemove.Contains(statement))

Diagnostics\Suppression\RemoveUnnecessaryPragmaSuppressionsTests.cs (1)

98if (usedLocals.Contains(local))

Symbols\CorLibrary\CorTypes.cs (2)

69if (knownMissingTypes.Contains(i)) 86if (knownMissingTypes.Contains(i))

Symbols\Metadata\MetadataMemberTests.cs (4)

626Assert.True(memberNames1.Contains(m), m); 636Assert.True(memberNames2.Contains(m), m); 667Assert.True(memberNames1.Contains(m), m); 678Assert.True(memberNames2.Contains(m), m);

Rename\CSharpRenameRewriterLanguageService.cs (2)

465if (identifierToken != default && !_annotatedIdentifierTokens.Contains(identifierToken)) 503if (_invocationExpressionsNeedingConflictChecks.Contains(node))

Simplification\Reducers\AbstractCSharpReducer.AbstractReductionRewriter.cs (1)

139if (node != newNode || _processedParentNodes.Contains(parentNode))

CodeDefinitionWindow\DefinitionContextTracker.cs (1)

80if (!_subscribedViews.Contains(textView) && !textView.Roles.Contains(PredefinedTextViewRoles.CodeDefinitionView))

Editor\TextBufferAssociatedViewService.cs (1)

152Contract.ThrowIfTrue(set.Contains(view));

Classification\AbstractClassifierTests.cs (1)

303where !classificationsSpans.Contains(t.TextSpan)

Rename\RenamerTests.cs (1)

80Assert.True(remainingErrors.Contains(error), $"Error '{error}' was unexpected");

Utilities\BloomFilterTests.cs (2)

59var actualContains = strings.Contains(test); 245var actualContains = strings.Contains(test);

AbstractTypeParameterChecker.cs (1)

32if (!_acceptableTypeParameters.Contains(symbol))

CodeFixes\FixAllOccurrences\AbstractFixAllCodeFixCodeAction.cs (1)

37&& s_predefinedCodeFixProviderNames.Contains(exportAttribute.Name);

CodeRefactorings\MoveType\AbstractMoveTypeService.MoveTypeEditor.cs (1)

268.DescendantNodes(spine.Contains)

Completion\Providers\ImportCompletionProvider\AbstractTypeImportCompletionProvider.cs (1)

144if (namespacesInScope.Contains(containingNamespace))

DocumentHighlighting\AbstractDocumentHighlightsService.cs (1)

292if (span != null && !spanSet.Contains(span.Value))

EditAndContinue\CommittedSolution.cs (1)

148return _staleProjects.Contains(id);

EmbeddedLanguages\Classification\AbstractEmbeddedLanguageClassificationService.cs (1)

122if (token.Span.IntersectsWith(_textSpan) && _owner.SyntaxTokenKinds.Contains(token.RawKind))

Extensions\ExtensionMessageHandlerService.cs (1)

204potentiallyRefersToUnregisteredHandlerName = unregisteredHandlerNames.Contains(messageName);

ExtractMethod\AbstractSyntaxTriviaService.Result.cs (1)

163if (set.Contains(key))

ExtractMethod\MethodExtractor.Analyzer.cs (1)

50=> readOutsideMap.Contains(symbol);

QuickInfo\AbstractEmbeddedLanguageQuickInfoProvider.cs (1)

31if (!_embeddedLanguageProviderFeature.SyntaxTokenKinds.Contains(token.RawKind))

RemoveUnusedVariable\AbstractRemoveUnusedVariableCodeFixProvider.cs (1)

187if (!nodesToRemove.Contains(variable))

Shared\Utilities\ExtractTypeHelpers.cs (1)

152if (!allReferencedTypeParameters.Contains(originalTypeParameter) &&

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

603!_propertiesWithShadowGetAccessorUsages.Contains(property);

src\Analyzers\Core\Analyzers\UseConditionalExpression\ForAssignment\UseConditionalExpressionForAssignmentHelpers.cs (1)

149declaredPatternSymbols.Contains(local))

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

451if (!methodParameterNames.Contains(argumentName))

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (2)

185if (alreadyCheckingTypes.Contains(constraint)) 206if (alreadyCheckingTypes.Contains(genericParam))

src\Analyzers\Core\CodeFixes\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (3)

97if (declarators.Contains(parentDeclaration)) 99Debug.Assert(childDeclarators.All(c => !declarators.Contains(c))); 106if (!declarators.Contains(childDeclarator))

SymbolSearch\Windows\SymbolSearchUpdateEngine.Update.cs (1)

150if (invalidChars.Contains(c))

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (1)

363canEditDocument = document != null && !linkedDocuments.Contains(document.Id);

EditAndContinue\RudeEditDiagnosticTests.cs (3)

83if (arg0.Contains(kind)) 89else if (arg2.Contains(kind)) 97else if (arg3.Contains(kind))

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

1403if (!set.Contains(item))

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

346if (set.Contains(method.Parameters[i]))

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\TemporarySet`1.cs (2)

68return storage.Contains(item); 77return storage.Contains(item);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

Host\TestUtils.cs (2)

55var mismatch1 = assetMapFromNewSolution.Where(p => !allChecksumsFromRequest.Contains(p.Key)).ToList(); 59var mismatch2 = assetMapFromIncrementalSolution.Where(p => !allChecksumsFromRequest.Contains(p.Key)).ToList();

Services\ProcessTelemetry\RemoteProcessTelemetryService.cs (1)

82bool logChecker(FunctionId id) => functionIdsSet.Contains(id);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

274if (!applicableAttributeNodes.Contains(node))

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

346if (set.Contains(method.Parameters[i]))

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\TemporarySet`1.cs (2)

68return storage.Contains(item); 77return storage.Contains(item);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

Verifiers\CSharpSourceGeneratorVerifier`1+Test.cs (1)

102if (!expectedNames.Contains(name.Substring(currentTestPrefix.Length)))

Verifiers\VisualBasicSourceGeneratorVerifier`1+Test.cs (1)

87if (!expectedNames.Contains(name.Substring(currentTestPrefix.Length)))

Hosting\AssemblyLoader\MetadataShadowCopyProvider.cs (1)

345if (_lazySuppressedFiles != null && _lazySuppressedFiles.Contains(key.FullPath))

Hosting\ObjectFormatter\CommonObjectFormatter.Visitor.cs (1)

436if (value != null && !VisitedObjects.Contains(value))

CommonTestBase.cs (1)

702Assert.True(set.Contains(operation));

CompilationVerifier.cs (1)

904if (isManifestModule && fullNameSet.Contains(identity!.GetDisplayName()))

Diagnostics\FieldCouldBeReadOnlyAnalyzer.cs (1)

92if (!field.IsConst && !field.IsReadOnly && !assignedToFields.Contains(field))

Diagnostics\LocalCouldBeConstAnalyzer.cs (1)

86if (!local.IsConst && !assignedToLocals.Contains(local))

Diagnostics\TrackingDiagnosticAnalyzer.cs (1)

139expectedArguments = expectedArguments.Where(a => !symbolKindsWithNoCodeBlocks.Contains(a.SymbolKind));

Metadata\MetadataSignatureUnitTestHelper.cs (2)

150if (!distinctSignatures.Contains(signature)) 161if (!distinctSignatures.Contains(signature))

Mocks\VirtualizedRelativePathResolver.cs (1)

28return _existingFullPaths.Contains(Path.GetFullPath(fullPath));

TestableFileSystem.cs (1)

60FileExistsFunc = filePath => set.Contains(filePath)

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

1403if (!set.Contains(item))

Collections\List\IEnumerable.Generic.Tests.cs (1)

642Assert.True(secondValues.Contains(item));

Collections\List\IEnumerable.NonGeneric.Tests.cs (1)

305Assert.True(secondValues.Contains(item));

CorLibTypesTests.cs (1)

80if (knownMissingTypes.Contains(specialType))

StrongNameProviderTests.cs (1)

86return fullPath != null && _existingFullPaths != null && _existingFullPaths.Contains(FileUtilities.NormalizeAbsolutePath(fullPath));

Analysis\FlowAnalysis\DataFlowsOutWalker.vb (3)

57Debug.Assert(Not success OrElse Not result.Any(Function(variable) Not walker._assignedInside.Contains(variable))) 149If Not _dataFlowsOut.Contains(local) AndAlso local.Kind <> SymbolKind.RangeVariable AndAlso Not IsInside Then 192Return Me._originalUnassigned.Contains(sym)

Binding\Binder_Lookup.vb (4)

812If Not conflictingMembers.Contains(sym) Then 1398If verified.Contains(i) Then 1511Debug.Assert(processed.Contains(info)) 1700If processedInterfaces Is Nothing OrElse Not processedInterfaces.Contains(newInfo) Then

Lowering\Diagnostics\DiagnosticsPass_ExpressionLambdas.vb (1)

146If Me._expressionTreePlaceholders.Contains(node) Then

Lowering\LambdaRewriter\LambdaRewriter.vb (5)

244If Not _analysis.variableScope.TryGetValue(captured, node) OrElse _analysis.declaredInsideExpressionLambda.Contains(captured) Then 550If _analysis.needsParentFrame.Contains(node) Then 643If Proxies.TryGetValue(originalSymbol, proxy) AndAlso Not _analysis.declaredInsideExpressionLambda.Contains(originalSymbol) Then 989If _analysis.needsParentFrame.Contains(scope) AndAlso 1360If _analysis.containsLiftingLambda.Contains(curBlock) Then

Symbols\Source\SourceFieldSymbol.vb (1)

284Debug.Assert(fields.All(Function(f) map.Contains(f)))

Symbols\Source\SourceNamedTypeSymbol.vb (3)

893If (constraintType IsNot Nothing) AndAlso Not constraintTypes1.Contains(constraintType) Then 961If Not typeParameterSet.Contains(s.Name) Then 1175If namedType IsNot Nothing AndAlso interfacesInThisPartial.Contains(namedType) Then

Syntax\SyntaxReplacer.vb (3)

152If Me._nodeSet.Contains(node) AndAlso Me._computeReplacementNode IsNot Nothing Then 167If Me._tokenSet.Contains(token) AndAlso Me._computeReplacementToken IsNot Nothing Then 181If Me._triviaSet.Contains(trivia) AndAlso Me._computeReplacementTrivia IsNot Nothing Then

Diagnostics\SkippedHostAnalyzersInfo.cs (1)

90if (projectAnalyzerIds.Contains(hostAnalyzerId))

FindSymbols\FindReferences\DependentProjectsFinder.cs (1)

279var hasInternalsAccess = internalsVisibleToSet.Contains(project.AssemblyName);

FindSymbols\FindReferences\DependentTypeFinder.cs (3)

314if (seenPEReferences.Contains(peReference)) 515return baseType != null && set.Contains(baseType); 522if (set.Contains(interfaceType.OriginalDefinition))

Rename\ConflictEngine\ConflictResolver.Session.cs (3)

310_documentOfRenameSymbolHasBeenRenamed |= documentIdsForConflictResolution.Contains(_documentIdOfRenameSymbolDeclaration); 438foreach (var unprocessedDocumentIdWithPotentialDeclarationConflicts in allDocumentIdsInProject.Where(d => !documentIdsForConflictResolution.Contains(d))) 738if (documentIds.Contains(document.Id))

Rename\ConflictEngine\RenamedSpansTracker.cs (1)

201.Where(x => !modifiedTokensInComplexifiedStatements.Contains((SyntaxToken)x))

Shared\Extensions\ISymbolExtensions.cs (1)

670!arg.overriddenSymbols.Contains(s) &&

Shared\Extensions\ITypeSymbolExtensions.cs (1)

109currentType.GetOriginalInterfacesAndTheirBaseInterfaces().Contains(interfaceType.OriginalDefinition);

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

87public bool Contains(T value) => _set?.Contains(value) ?? false;

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

1403if (!set.Contains(item))

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

188if (set.Contains(ancestor))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\CustomDataFlowAnalysis.cs (2)

118if (processedBlocks.Contains(current)) 238(!analyzer.IsEqual(currentDestinationData, mergedAnalysisData) || !processedBlocks.Contains(destination)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\LValueFlowCaptureProvider.cs (2)

61var captureKind = flowCaptureReference.Parent.IsAnyCompoundAssignment() || rvalueFlowCaptureIds.Contains(flowCaptureReference.Id) 76Debug.Assert(kind == FlowCaptureKind.LValueAndRValueCapture || !rvalueFlowCaptureIds.Contains(captureId), "Flow capture used as both an r-value and an l-value, but with incorrect flow capture kind");

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

210if (_referenceTakenSymbolsBuilder.Contains(symbol))

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

227if (write != null && operations.Contains(write))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\BottomUpBaseIndentationFinder.cs (1)

320if (map.Contains(operation.TextSpan))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.cs (5)

184_indentationMap.Contains(intervalTreeSpan)) 309if (!option.IsMaskOn(SuppressOption.NoSpacing) || _suppressSpacingMap.Contains(operation.TextSpan)) 336if (!option.IsOn(SuppressOption.DisableFormatting) || _suppressFormattingMap.Contains(operation.TextSpan)) 356if (!option.IsMaskOn(SuppressOption.NoWrapping) || _suppressWrappingMap.Contains(operation.TextSpan)) 380_anchorMap.Contains(operation.TextSpan) ||

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

106if (!referencedElements.Contains(namingStyle.ID))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService_FindDeclaration.cs (1)

212TryAddToWorker(declarations, checkGeneratedCode, out declaration, out availableIndices, d => ancestors.Contains(d)) ||

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

136if (addedSymbols.Contains(namespaceSymbol))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

128FirstStatementAffectedInInnermostBlock = InnermostBlockStatements.Cast<TStatementSyntax>().FirstOrDefault(allAffectedStatements.Contains);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (2)

32while (nameSet.Contains(result)) 123while (usedNames.Contains(updatedName) || !canUse(updatedName))

Utilities\WeakSet`1.cs (1)

32return _values.Contains(ReferenceHolder<T>.Strong(value));

Workspace\ProjectSystem\ProjectSystemProject.cs (2)

1078if (_projectAnalyzerPaths.Contains(mappedFullPath)) 1121if (!_projectAnalyzerPaths.Contains(mappedFullPath))

Workspace\Solution\ProjectChanges.cs (6)

29if (!oldRefs.Contains(reference)) 41if (!newRefs.Contains(reference)) 53if (!oldMetadata.Contains(metadata)) 65if (!newMetadata.Contains(metadata)) 77if (!oldAnalyzerReferences.Contains(analyzerReference)) 89if (!newAnalyzerReferences.Contains(analyzerReference))

Workspace\Solution\SolutionChanges.cs (2)

68if (!oldAnalyzerReferences.Contains(analyzerReference)) 80if (!newAnalyzerReferences.Contains(analyzerReference))

Workspace\Solution\SolutionCompilationState.cs (2)

336static (projectId, dependentProjects) => !dependentProjects.Contains(projectId), 384static (projectId, dependentProjects) => !dependentProjects.Contains(projectId),

Workspace\Solution\SolutionCompilationState.RegularCompilationTracker.cs (1)

988ThrowExceptionIfFalse(syntaxTreesInWorkspaceStates.Contains(tree), "The tree in the Compilation should have been from the workspace.");

Workspace\Solution\SolutionState.cs (1)

477var newProjectIds = ProjectIds.Where(p => !projectIdsSet.Contains(p)).ToBoxedImmutableArray();

Workspace\Solution\TextDocumentStates.cs (1)

169if (ids.All(static (id, set) => set.Contains(id), set))

Workspace\Workspace.cs (2)

385if (!changedDocumentIds.Contains(relatedDocumentId)) 1654if (!infoChangedDocumentIds.Contains(docId))

Workspace\Workspace_Editor.cs (1)

183openDocuments.Contains(documentId);

MSBuild\MSBuildProjectLoader.Worker.cs (1)

487if (paths.Contains(doc.FilePath))

MSBuild\MSBuildProjectLoader.Worker_ResolveReferences.cs (1)

170if (!_indicesToRemove.Contains(index) && set.Add(reference))

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

87public bool Contains(T value) => _set?.Contains(value) ?? false;

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

1403if (!set.Contains(item))

FindReferencesTests.cs (1)

400Assert.True(projectIds.Contains(netCoreProject.Id));

Microsoft\CSharp\RuntimeBinder\SymbolTable.cs (2)

71if (s_namesLoadedForEachType.Contains(key)) 144Debug.Assert(!s_namesLoadedForEachType.Contains(key));

DataFrame.Join.cs (2)

302if (!intersection.Contains(supplementaryRowIndex)) 393if (!intersection.Contains(i))

IDataView.Extension.cs (1)

60if (dataViewColumn.IsHidden || (selectColumnsSet != null && !selectColumnsSet.Contains(dataViewColumn.Name)))

DataFrame.IOTests.cs (1)

1721if (possibleTypes.Contains(type))

DataFrameTests.Merge.cs (2)

779if (left.Columns["Int"][i] != null && intersection.Contains((int)left.Columns["Int"][i])) 795if (right.Columns["Int"][i] != null && intersection.Contains((int)right.Columns["Int"][i]))

PipelinesLogger.cs (1)

240if (_ignoredTargets.Contains(e.TargetNames))

AssemblySet.cs (3)

149if (assembliesSnapshot.Any(a => !loadedAssembliesSet.Contains(a))) 201: includedAssemblySet.Contains(resolved) 203: requiredAssemblySet.Contains(resolved)

ApplyMetaPackages.cs (2)

131(value.Contains("All") || value.Contains(tfm.DotNetFrameworkName));

FilterUnknownPackages.cs (1)

47isKnownPackage = packageId => baseLinePackageIds.Contains(packageId);

GeneratePackageReport.cs (1)

270if (s_ignoredFrameworks.Contains(derivedFx.Framework))

GetLayoutFiles.cs (1)

85if (rid != null && rids.Count > 0 && !rids.Contains(rid))

GetPackageDestination.cs (1)

90!suppressions.Contains(packageFx))

HarvestPackage.cs (1)

377if (preserveRefVersion.Contains(liveFile.Version))

PackageIndex.cs (4)

111if (!IndexSources.Contains(otherIndexFile)) 321isStable = info.StableVersions.Contains(packageVersion); 435bool existingStable = StableVersions.Contains(existingPackageVersion); 436bool updateStable = StableVersions.Contains(packageVersion);

UpdatePackageIndex.cs (2)

307.Where(pair => pair.Value == packageVersion && !assmVersions.Contains(pair.Key)) 354return (_packageIdsToInclude != null) ? _packageIdsToInclude.Contains(packageId) : true;

ValidateFrameworkPackage.cs (2)

51var logMissingInbox = permittedInbox.Contains(name) ? 75var logMissingPackage = permittedMissingInbox.Contains(missingInboxAssembly.Key) ?

ValidatePackage.cs (4)

339if (!implementationAssembly.TargetFramework.Equals(fx) && !runtimeFxSuppression.Contains(fx.ToString())) 405if (!info.StableVersions.Contains(packageVersion) && packageVersion != thisPackageVersion) 413.Where(pair => pair.Value == thisPackageVersion && !assemblyVersions.Contains(pair.Key)) 543if (explicitlySupportedFrameworks.Contains(fx))

ValidationTask.cs (2)

81return values.Contains(value); 92return frameworkValues.Any(fx => values.Contains(fx));

Analyzers\PinvokeAnalyzer.cs (1)

115if (_isNotSupportedOnWin7.Contains(methodName))

SourceGenerator.cs (2)

56IEnumerable<string> typesToForward = compileFiles == null ? _referenceTypes : _referenceTypes.Where(id => !existingTypes.Contains(id)); 63if (!ignoreMissingTypes && !_ignoreMissingTypesList.Contains(type))

TypeParser.cs (2)

65if (!types.Contains(fullyQualifiedName)) 88if (!types.Contains(fullyQualifiedName))

CheckAzurePipelinesTestResults.cs (1)

227if (expectedFailures.Contains(testName))

VerifyClosure.cs (1)

188if (!otherFiles.Contains(moduleReference))

VerifyTypes.cs (1)

57if (ignoredTypes.Contains(type))

src\CreateFrameworkListFile.cs (1)

244!singleFileHostIncludeFilenames.Contains(f.Filename))

src\FileUtilities.cs (1)

34if (!s_assemblyExtensions.Contains(Path.GetExtension(path)))

src\Microsoft.DotNet.PackageTesting\VerifyClosure.cs (1)

188if (!otherFiles.Contains(moduleReference))

src\Microsoft.DotNet.PackageTesting\VerifyTypes.cs (1)

57if (ignoredTypes.Contains(type))

Verification\Exclusion.cs (1)

180=> cache.TryGetValue(key, out var cachedValues) && values.Any(cachedValues.Contains);

src\BatchSignUtil.cs (3)

225var repackList = files.Where(w => toRepackSet.Contains(w.FullPath)).ToList(); 301trackedSet.Contains(x.FileSignInfo.FileContentKey)) && !toRepackSet.Contains(x.FileSignInfo.FullPath)

src\Configuration.cs (1)

543if (SignToolConstants.SignableExtensions.Contains(extension))

src\SignTool.cs (1)

68var osxFilesToZip = filesToSign.Where(fsi => SignToolConstants.MacSigningOperationsRequiringZipping.Contains(fsi.SignInfo.Certificate));

src\SignToolTask.cs (1)

426if (!extension.Equals(Path.GetExtension(extension)) && !specialExtensions.Contains(extension))

src\UsageReport\WritePackageUsageData.cs (1)

209.Where(id => properties.Contains(id.Id + "/" + id.Version.OriginalVersion)))

src\UsageReport\WriteUsageReports.cs (1)

152EndsUpInOutput = poisonNupkgFilenames.Contains($"{id}.{version}")

Model\VsctDocument.cs (1)

23if (nonUniqueIds.Contains(id))

Utility\ReadOnlySet.cs (1)

17 public bool Contains(T item) => hashSet.Contains(item);

Commands\CleanResultsCommand.cs (1)

72if (!toPreserve.Contains(executionName))

MetadataSerializer.cs (1)

129if (CharsToEscapeHash.Contains(@char))

ConfigurationBinder.cs (2)

235if (!propertyNames.Contains(cs.Key)) 594if (!propertyNames.Contains(name))

ServiceLookup\CallSiteFactory.cs (1)

635if (!bestConstructorParameterTypes.Contains(p.ParameterType))

AutoActivationExtensions.cs (2)

35if (ao.AutoActivators.Contains(constructed)) 69if (ao.AutoActivators.Contains(constructed))

AutoActivationExtensions.Keyed.cs (2)

34if (ao.KeyedAutoActivators.Contains((constructed, serviceKey))) 72if (ao.KeyedAutoActivators.Contains((constructed, serviceKey)))

Metrics\MetricCollector.cs (1)

110if (!_supportedTs.Contains(typeof(T)))

Internal\MatcherContext.cs (1)

74_declaredLiteralFolderSegmentInString.Contains(candidate.Name))

DependencyInjection\HttpClientBuilderExtensions.cs (1)

586options.ShouldRedactHeaderValue = (header) => sensitiveHeaders.Contains(header);

LoggerMessageGenerator.Parser.cs (1)

696if (shadowedNames.Contains(parameter.Name))

DataAnnotationValidateOptions.cs (1)

78if (visited is not null && visited.Contains(options))

Parser.cs (1)

286var baseMembers = baseType.GetMembers().Where(m => !addedMembers.Contains(m.Name));

ServiceDiscoveryHttpClientBuilderExtensions.cs (2)

67_global = _options.ClientNames.Contains(null); 76if (_global || _options.ClientNames.Contains(builder.Name))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

Parsing\Parser.cs (1)

718if (shadowedNames.Contains(parameter.Name))

Parsing\Parser.LogProperties.cs (1)

338_allowedTypeKinds.Contains(symType.TypeKind) &&

Parsing\Parser.Records.cs (2)

107overriddenMembers.Contains(property.Name)) 134if (typesChain.Contains(extractedType))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

414if (!_allowedGenericAttributeTypeArgs.Contains(genericType.SpecialType))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

Parser.cs (1)

414if (!_allowedGenericAttributeTypeArgs.Contains(genericType.SpecialType))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

414if (!_allowedGenericAttributeTypeArgs.Contains(genericType.SpecialType))

src\Generators\Shared\GeneratorUtilities.cs (2)

95return shortAttributeNames.Contains(id.Identifier.Text); 111if (attributeType != null && fullyQualifiedAttributeNames.Contains(GetAttributeDisplayName(attributeType)))

Analyzers\ConvertComImportToGeneratedComInterfaceAnalyzer.cs (1)

94if (s_unsupportedTypeNames.Contains(info.ManagedType.FullTypeName))

Analyzers\CustomMarshallerAttributeFixer.cs (19)

Hosting\Internal\RegisteredHandlerServiceTypeSet.cs (2)

34 if (_concreteHandlerServiceTypeSet.Contains(type) 35 || _interfaceHandlerServiceTypeSet.Contains(type))

Platform\ElementExtensions.cs (1)

78 if (handlersWithConstructors.Contains(viewType))

Element\Element.cs (1)

663 bool waitForHandlerUpdateToFireFromBP = _pendingHandlerUpdatesFromBPSet.Contains(propertyName);

ListProxy.cs (1)

185 if (_indexesCounted.Contains(index))

Shell\ShellUriHandler.cs (3)

405 if (routeKeys.Contains(searchPath)) 413 if (routeKeys.Contains(segment)) 598 if (routeKeys.Contains(possibleRoutePath.NextSegment))

TemplatedItemsList.cs (1)

1294 if (_attachedItems.Contains(list))

ColorDesignTypeConverter.cs (1)

199 if (knowValuesSet.Contains(str.Trim()))

VisibilityDesignTypeConverter.cs (1)

20 return supportedValues.Contains(strValue);

AutoMLExperiment\ITrialResultManager.cs (1)

61if (_trialResultsHistory.Contains(result))

PipelineSuggesters\PipelineSuggester.cs (2)

80if (!visitedPipelines.Contains(suggestedPipeline)) 114return history.Where(h => selectedTrainerNames.Contains(h.Pipeline.Trainer.TrainerName))

TransformInference\TransformInference.cs (2)

482if (!existingColNames.Contains(desiredColName)) 491if (!existingColNames.Contains(newColName))

CodeGenerator\CSharp\CodeGenerator.cs (6)

111if (_lightGbmTrainers.Contains(currentNode.Name)) 115else if (_mklComponentsTrainers.Contains(currentNode.Name)) 119else if (_fastTreeTrainers.Contains(currentNode.Name)) 123else if (_imageTransformers.Contains(currentNode.Name)) 127else if (_imageClassificationTrainers.Contains(currentNode.Name)) 131else if (_recommendationTrainers.Contains(currentNode.Name))

Data\ProgressReporter.cs (1)

450unseen = _infos.Where(x => !seen.Contains(x.Index)).ToArray();

UnitTests\TestEntryPoints.cs (1)

306if (excludeSet.Contains(ep["Name"].ToString()))

UnitTests\TestVBuffer.cs (1)

334if (aIndices.Contains(i))

Data\DataViewTypeManager.cs (1)

180if (_bannedRawTypes.Contains(type))

DataLoadSave\Binary\BinarySaver.cs (2)

587using (DataViewRowCursor cursor = data.GetRowCursor(data.Schema.Where(c => activeSet.Contains(c.Index)))) 745using (DataViewRowCursor cursor = data.GetRowCursor(data.Schema.Where(x => active.Contains(x.Index)), rand))

DataView\CacheDataView.cs (1)

350cursor = _subsetInput.GetRowCursor(_subsetInput.Schema.Where(c => taskColumns.Contains(c.Index)));

DataView\Transposer.cs (1)

885return activeSrcSet.Contains;

Evaluators\EvaluatorBase.cs (1)

81return i => pred(i) || stratIndices.Contains(i);

Model\Pfa\BoundPfaContext.cs (5)

71if (toDrop.Contains(name)) 76string fieldName = ModelUtils.CreateNameCore(name, fieldNames.Contains); 137string fieldName = ModelUtils.CreateNameCore(name, fieldNames.Contains); 275if (_unavailable.Contains(name)) 289return !_unavailable.Contains(name) && _nameToVarName.TryGetValue(name, out name) && (name == "input" || name.StartsWith("input."));

Model\Pfa\PfaContext.cs (4)

161if (_variables.Contains(l.Key)) 175if (!_variables.Contains(l.Key)) 209public bool ContainsVar(string name) => _variables.Contains(name); 213public bool ContainsType(string name) => _types.Contains(name);

Model\Pfa\SavePfaCommand.cs (1)

193if (_outputsToDrop.Contains(name))

Scorers\RowToRowScorerBase.cs (1)

172Func<int, bool> activeInfos = iinfo => activeIndices.Contains(bindings.MapIinfoToCol(iinfo));

Transforms\MetadataDispatcher.cs (2)

238if (kinds != null && kinds.Contains(kvp.Key)) 367return new Builder(this, index, schemaSrc, indexSrc, (k, i) => set.Contains(k));

Transforms\TransformBase.cs (1)

825return activeIndices.Contains(col);

Transforms\ValueMapping.cs (1)

294if (valueSet.Contains(v))

Transforms\ValueToKeyMappingTransformer.cs (1)

587using (var cursor = trainingData.GetRowCursor(trainingData.Schema.Where(c => toTrain.Contains(c.Index))))

PipelineEnsemble.cs (1)

100return InputSchema.Where(col => _inputColIndices.Contains(col.Index));

Training\DocumentPartitioning.cs (1)

268if (categoricalIndices.Contains(hotFeature - 1))

ContractsCheckAnalyzer.cs (1)

191if ((!(isCheck = name.StartsWith("Check")) && !(isExcept = name.StartsWith("Except"))) || !_targetSet.Contains(name))

OnnxContextImpl.cs (5)

68public override bool IsVariableDefined(string variableName) => _variableNames.Contains(variableName); 121Contracts.Assert(_variableNames.Contains(columnName)); 133return GetUniqueName(prefix, _nodeNames.Contains); 149_host.Assert(!_nodeNames.Contains(node.Name)); 220_columnNameMap[colName] = makeUniqueName ? GetUniqueName(colName, _variableNames.Contains) : colName;

SaveOnnxCommand.cs (4)

174if (inputColumnNamesToDrop.Contains(colName)) 200if (inputColumnNamesToDrop.Contains(idataviewColumnName) || outputColumnNamesToDrop.Contains(idataviewColumnName)) 272if (outputColumnNames.Contains(col.Name))

OnnxUtils.cs (2)

536if (!_onnxTypeMap.Contains(typeof(T))) 556if (!_onnxTypeMap.Contains(typeof(T)))

TestTransposer.cs (1)

127if (forceDenseSlotSet.Contains(i) || rgen.NextDouble() < density)

Scenarios\ClusteringTests.cs (1)

78Assert.True(!labels.Contains(scores.SelectedClusterId));

Transformers\CustomMappingTests.cs (1)

155output.FirstAppearance = !state.SeenValues.Contains(input.Value);

PredictionEngine.cs (1)

175bool wantsActive = activeIndices.Contains(c);

LoadTransform.cs (1)

94bool found = allTags.Contains(tag.ToLower());

MutualInformationFeatureSelection.cs (1)

195CreateDropAndCopyColumns(colArr.Length, scores, threshold, tiedScoresToKeep, _columns.Where(col => colSet.Contains(col.inputColumnName)).ToArray(), out int[] selectedCount, out dropSlotsColumns, out copyColumnPairs);

OptionalColumnTransform.cs (1)

382return activeIndices.Contains(col);

ChangeSignature\ChangeSignatureDialogViewModel.cs (1)

506return _disabledParameters.Contains(parameterViewModel);

CommonControls\MemberSelectionViewModel.cs (1)

186if (!visited.Contains(dependent))

MoveStaticMembers\StaticMemberSelectionViewModel.cs (1)

99if (!visited.Contains(dependent))

Modifiers.cs (2)

235bool result = s_tableOfItemSpecModifiers.Contains(name); 296bool result = s_tableOfItemSpecModifiers.Contains(name);

XMake.cs (2)

3567if (!extensionsToIgnore.Contains(Path.GetExtension(s)) && !s.EndsWith("~", StringComparison.CurrentCultureIgnoreCase)) 3582if (!extensionsToIgnore.Contains(Path.GetExtension(s)))

XMakeAttributes.cs (5)

126return KnownSpecialTaskAttributes.Contains(attribute); 136return !IsSpecialTaskAttribute(attribute) && KnownSpecialTaskAttributesIgnoreCase.Contains(attribute); 146return KnownBatchingTargetAttributes.Contains(attribute); 154return runtime == null || ValidMSBuildRuntimeValues.Contains(runtime); 162return architecture == null || ValidMSBuildArchitectureValues.Contains(architecture);

BinaryTranslator.cs (1)

617if (additionalEntriesKeys.Contains(key))

Modifiers.cs (2)

235bool result = s_tableOfItemSpecModifiers.Contains(name); 296bool result = s_tableOfItemSpecModifiers.Contains(name);

XMakeAttributes.cs (5)

126return KnownSpecialTaskAttributes.Contains(attribute); 136return !IsSpecialTaskAttribute(attribute) && KnownSpecialTaskAttributesIgnoreCase.Contains(attribute); 146return KnownBatchingTargetAttributes.Contains(attribute); 154return runtime == null || ValidMSBuildRuntimeValues.Contains(runtime); 162return architecture == null || ValidMSBuildArchitectureValues.Contains(architecture);

MS\Internal\Tasks\IncrementalCompileAnalyzer.cs (1)

397if (localMarkupPages.Contains(localRefFile.FilePath))

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (1)

1963return _all || (_names is not null && _names.Contains(elementName));

MS\Internal\Resources\ContentFileHelper.cs (1)

28if (_contentFiles.Contains(partName))

System\Windows\Automation\Peers\AutomationPeer.cs (1)

1918if(hs != null && hs.Contains(child))

MS\Internal\WindowsRuntime\Generated\WinRT\Projections.cs (1)

210if (ProjectedRuntimeClassNames.Contains(runtimeClassName))

System\Windows\Markup\RestrictiveXamlXmlReader.cs (5)

141if (SafeTypesFromRegistry.Contains("*")) 153if (AllXamlNamespaces.Contains(xmlns)) 186if (type is null || SafeTypesFromRegistry.Contains("*") || _safeTypesSet.Contains(type) || SafeTypesFromRegistry.Contains(type.FullName))

System\Windows\Markup\XamlTypeMapperSchemaContext.cs (1)

367if (!_clrNamespaces.Contains(xamlNamespace))

AbstractDoNotCopyValue.cs (2)

508var currentIsHandled = _handledOperations.Contains(operation); 1641if (_handledOperations.Contains(operation))

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

274if (!applicableAttributeNodes.Contains(node))

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

346if (set.Contains(method.Parameters[i]))

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\TemporarySet`1.cs (2)

68return storage.Contains(item); 77return storage.Contains(item);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

AssemblyScheduler.cs (1)

145var unmatchedRemoteTests = testHistory.Keys.Where(type => !matchedRemoteTests.Contains(type));

src\libraries\Common\src\System\CSharpHelpers.cs (1)

126return s_fixedStringLookup.Contains(value);

System\Collections\Frozen\FrozenSet.cs (1)

135!source.Contains(default!) &&

System\ComponentModel\Composition\AttributedModel\AttributedPartCreationInfo.cs (2)

273if (!_contractNamesOnNonInterfaces.Contains(attributedExportDefinition.ContractName)) 298if (!_contractNamesOnNonInterfaces.Contains(attributedExportDefinition.ContractName))

System\ComponentModel\Composition\Hosting\CatalogExportProvider.CatalogChangeProxy.cs (1)

40!_removedParts.Contains(partAndExport.Item1));

System\ComponentModel\Composition\Hosting\CatalogExportProvider.cs (2)

675if (_rejectedParts.Contains(definition)) 1010return _parts.Contains(part);

System\ComponentModel\Composition\Hosting\FilteredCatalog.Traversal.cs (1)

72return new FilteredCatalog(_innerCatalog, traversalClosure.Contains);

System\Composition\Hosting\Core\ExportDescriptorRegistryUpdate.cs (2)

68if (@checked.Contains(dependency.Target)) 81if (@checked.Contains(dependency.Target))

System\Data\TypeLimiter.cs (2)

237if (currentScope.m_allowedTypes.Contains(type)) 269if (s_allowedTypes.Contains(type))

System\Diagnostics\DsesActivitySourceListener.cs (1)

133&& _listenToActivitySourceNames.Contains(activitySource.Name));

System\IO\Packaging\XmlCompatibilityReader.cs (2)

1740return _all || (_names != null && _names.Contains(elementName)); 1791return _all || (_names != null && _names.Contains(itemName));

System\Dynamic\Utils\Helpers.cs (1)

26if (set.Contains(t))

System\Linq\Expressions\Compiler\LabelInfo.cs (1)

135if (_definitions.Contains(j))

System\Linq\Expressions\Interpreter\LabelInfo.cs (2)

180return definitions.Contains(scope); 233if (set.Contains(t))

System\Runtime\CompilerServices\RuntimeOps.ExpressionQuoter.cs (1)

188if (hidden.Contains(variable))

System\Linq\Parallel\QueryOperators\Binary\ExceptQueryOperator.cs (1)

294if (rightLookup.Contains(leftElement.First))

src\libraries\System.Private.CoreLib\src\Internal\Runtime\InteropServices\ComponentActivator.cs (1)

149if (s_loadedInDefaultContext.Contains(assemblyPath))

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\HashSet.cs (2)

1537if (!other.Contains(item)) 1559if (!other.Contains(item))

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValues.cs (2)

53if (uniqueValues.Contains(string.Empty)) 103if (!unreachableValues.Contains(value))

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValuesBase.cs (1)

31return _uniqueValues.Contains(value);

src\System\Reflection\RuntimeCustomAttributeData.cs (4)

1989if (!all && !s_pca.Contains(caType)) 2033if (!all && !s_pca.Contains(caType)) 2073if (!all && !s_pca.Contains(caType)) 2129if (!all && !s_pca.Contains(caType))

IntrinsicsInSystemPrivateCoreLibAnalyzer.cs (5)

416if (symbol.ContainingType != null && !examinedSymbols.Contains(symbol.ContainingType)) 418if (symbol.BaseType != null && !examinedSymbols.Contains(symbol.BaseType)) 438if (symbol.ContainingType != null && !examinedSymbols.Contains(symbol.ContainingType)) 440if (symbol.BaseType != null && !examinedSymbols.Contains(symbol.BaseType)) 685if (onLoadData.NamedTypesToBeProtected.Contains(symbol.ContainingType))

System\Runtime\Serialization\DataContract.cs (2)

1143if (previousCollectionTypes.Contains(itemType)) 2095if (checkedContracts.Contains(contractPairKey))

System\Private\Windows\BinaryFormat\Deserializer\Deserializer.cs (1)

321if (_pendingSerializationInfoIds is not null && _pendingSerializationInfoIds.Contains(completed))

System\Private\Windows\BinaryFormat\Deserializer\ObjectRecordDeserializer.cs (1)

94|| (Deserializer.IncompleteObjects.Contains(valueRecord) && value.GetType().IsValueType));

BinarySerialization.cs (2)

34if (serializableTypes.Contains(fullName)) 49if (serializableTypes.Contains(fullName))

src\libraries\Common\src\System\CSharpHelpers.cs (1)

126return s_fixedStringLookup.Contains(value);

System\Xml\Core\XmlTextReaderImpl.cs (1)

8065if (_currentEntities.Contains(entity))

System\Xml\Dom\XmlLoader.cs (1)

702if (attr.Prefix == _doc.strXmlns && !prefixes.Contains(attr.LocalName))

System\Xml\Serialization\XmlSerializationILGen.cs (1)

119if (!_generatedMethods.Contains(mapping))

System\Xml\Serialization\XmlSerializationWriter.cs (1)

1469while (_usedPrefixes.Contains(++_tempNamespacePrefix)) { }

System\Resources\Extensions\BinaryFormat\Deserializer\Deserializer.cs (1)

326if (_pendingSerializationInfoIds is not null && _pendingSerializationInfoIds.Contains(completed))

System\Resources\Extensions\BinaryFormat\Deserializer\ObjectRecordDeserializer.cs (1)

93|| (Deserializer.IncompleteObjects.Contains(valueRecord) && value.GetType().IsValueType));

System\Runtime\Serialization\Schema\CodeExporter.cs (2)

1379if (contractCodeDomInfo.GetMemberNames().Contains(memberName)) 1385if (!contractCodeDomInfo.GetMemberNames().Contains(uniqueMemberName))

System\Runtime\Serialization\Schema\ContractCodeDomInfo.cs (1)

60Debug.Assert(!names.Contains(memberName));

System\Security\Cryptography\X509Certificates\ManagedCertificateFinder.cs (1)

239return policyOids.Contains(oidValue);

System\Security\Cryptography\X509Certificates\OpenSslCachedSystemStoreProvider.cs (1)

218if (processedFiles.Contains(fileId))

System\ServiceModel\Syndication\SyndicationFeed.cs (1)

353private static bool IsValidDay(string day) => s_acceptedDays.Contains(day);

System\Text\RegularExpressions\RegexCharClass.cs (1)

337Debug.Assert(whitespaceSet.Contains((char)i) == char.IsWhiteSpace((char)i));

System\Text\RegularExpressions\RegexTreeAnalyzer.cs (6)

124if (results._containsCapture.Contains(child)) 133if (!isAtomicBySelf && (results._mayBacktrack?.Contains(child) == true)) 183public bool IsAtomicByAncestor(RegexNode node) => _isAtomicByAncestor.Contains(node); 191public bool MayContainCapture(RegexNode node) => !_complete || _containsCapture.Contains(node); 204public bool MayBacktrack(RegexNode node) => !_complete || (_mayBacktrack?.Contains(node) ?? false); 224public bool IsInLoop(RegexNode node) => !_complete || (_inLoops?.Contains(node) ?? false);

System\Text\RegularExpressions\Symbolic\SymbolicRegexNode.cs (1)

550if (!seenElems.Contains(elems[i]))

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexCharClass.cs (1)

337Debug.Assert(whitespaceSet.Contains((char)i) == char.IsWhiteSpace((char)i));

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexTreeAnalyzer.cs (6)

124if (results._containsCapture.Contains(child)) 133if (!isAtomicBySelf && (results._mayBacktrack?.Contains(child) == true)) 183public bool IsAtomicByAncestor(RegexNode node) => _isAtomicByAncestor.Contains(node); 191public bool MayContainCapture(RegexNode node) => !_complete || _containsCapture.Contains(node); 204public bool MayBacktrack(RegexNode node) => !_complete || (_mayBacktrack?.Contains(node) ?? false); 224public bool IsInLoop(RegexNode node) => !_complete || (_inLoops?.Contains(node) ?? false);

UpgradeToGeneratedRegexAnalyzer.cs (2)

75methodNames.Contains(method.Name)) 102if (staticMethodsToDetect.Contains(method))

Microsoft\Windows\Controls\Ribbon\Primitives\RibbonMenuItemsPanel.cs (1)

222if (starLayoutTargets.Contains(child))

System\Windows\Forms\ActiveX\AxHost.AxContainer.cs (3)

96if (control != _parent && !GetComponents().Contains(control)) 129if (_containerCache.Contains(control)) 288if (!allowContainingControls && control != _parent && !GetComponents().Contains(control))

System\Windows\Forms\Application.cs (1)

992if (form is null || processedForms.Contains(form))

System\Windows\Forms\Controls\ListView\ListView.ColumnHeaderCollection.cs (1)

276if (!usedIndices.Contains(header.DisplayIndex) && header.DisplayIndex >= 0 && header.DisplayIndex < values.Length)

System\Windows\Forms\Controls\PropertyGrid\PropertyGrid.cs (1)

1057if (typesWithEvents is not null && typesWithEvents.Contains(objectType))

System\Windows\Forms\Controls\WebBrowser\WebBrowserContainer.cs (2)

260if (ctl != _parent && !_components.Contains(ctl)) 305if (_containerCache.Contains(ctl))

System\Windows\Forms\ToolTip\ToolTip.cs (4)

850if (!_created.Contains(control) 874if (!_created.Contains(control) && control.IsHandleCreated && TopLevelControl is not null) 879if (_created.Contains(control)) 911if (_created.Contains(control) && handlesCreated && !DesignMode)

System\ComponentModel\Design\DesignSurfaceServiceContainer.cs (1)

44if (serviceType is not null && _fixedServices.Contains(serviceType))

System\ComponentModel\Design\Serialization\CodeDomDesignerLoader.cs (1)

1066if (!conflict && memberHash.Contains(finalName))

System\ComponentModel\Design\Serialization\DesignerSerializationManager.cs (1)

486if (_defaultProviderTable is null || !_defaultProviderTable.Contains(serializerType))

System\Windows\Forms\Design\Behavior\BehaviorService.cs (1)

825(_hitTestedGlyph is not null && !_dragEnterReplies.Contains(_hitTestedGlyph)))

System\Windows\Forms\Design\ControlCommandSet.cs (1)

324if (itemHash.Contains(parent) && parent != component)

System\Windows\Forms\Design\DataGridViewColumnCollectionDialog.cs (1)

229if (_userAddedColumns.Contains(_columnsPrivateCopy[i]))

System\Windows\Forms\Design\TabOrder.cs (1)

272if (_tabComplete is not null && !_tabComplete.Contains(control))

System\Windows\Forms\SourceGenerators\EnumValidationGenerator.cs (1)

219if (enumType is null || foundTypes.Contains(enumType))

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (1)

1963return _all || (_names is not null && _names.Contains(elementName));

System\Xaml\Context\NameFixupGraph.cs (1)

125return _uninitializedObjectsAtParseEnd.Contains(instance);

System\Xaml\InfosetObjects\XamlObjectWriter.cs (1)

1520if (setProperties.Contains(property))

System\Xaml\XamlObjectReader.cs (1)

1059if (!namesOfAttributableProperties.Contains(dependingProperty.Name))

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

src\Shared\CertificateGeneration\UnixCertificateManager.cs (2)

497return _availableCommands.Contains(command); 521if (!availableCommands.Contains(command))

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

346if (set.Contains(method.Parameters[i]))

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\TemporarySet`1.cs (2)

68return storage.Contains(item); 77return storage.Contains(item);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

CodeAnalysisDictionary.cs (2)

105=> _unrecognizedWords.Contains(word); 108=> _recognizedWords.Contains(word);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

274if (!applicableAttributeNodes.Contains(node))

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

346if (set.Contains(method.Parameters[i]))

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\TemporarySet`1.cs (2)

68return storage.Contains(item); 77return storage.Contains(item);

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

112if (!processedRulesetPaths.Contains(rulesetIncludePath))

Sdk\AssertHelper.cs (2)

443 if (expectedRefs.Contains(expected)) 446 if (actualRefs.Contains(actual))

Sdk\CollectionTracker.cs (1)

210 if (!dictionaryYKeys.Contains(key))

StringAsserts.cs (7)

933 if (ignoreLineEndingDifferences && charsLineEndings.Contains(expectedChar) && charsLineEndings.Contains(actualChar)) 938 else if (ignoreAllWhiteSpace && (charsWhitespace.Contains(expectedChar) || charsWhitespace.Contains(actualChar))) 943 else if (ignoreWhiteSpaceDifferences && charsWhitespace.Contains(expectedChar) && charsWhitespace.Contains(actualChar)) 1685 if (charsWhitespace.Contains(value[index]))