SequenceEqual

Commands\Run\VirtualProjectBuildingCommand.cs (1)

1006else if (!cache.PreviousEntry.Directives.SequenceEqual(cache.CurrentEntry.Directives))

src\roslyn\src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

61other is not null && BaseDirectory == other.BaseDirectory && SearchPaths.SequenceEqual(other.SearchPaths);

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

203_many.SequenceEqual(other._many, comparer);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (3)

368return SymbolSpecifications.SequenceEqual(other.SymbolSpecifications) 369&& NamingStyles.SequenceEqual(other.NamingStyles) 370&& Rules.NamingRules.SequenceEqual(other.Rules.NamingRules);

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

198&& ApplicableSymbolKindList.SequenceEqual(other.ApplicableSymbolKindList) 199&& ApplicableAccessibilityList.SequenceEqual(other.ApplicableAccessibilityList) 200&& RequiredModifierList.SequenceEqual(other.RequiredModifierList);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ImmutableArrayComparer.cs (1)

20=> x.SequenceEqual(y);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (2)

62return property1.Parameters.SequenceEqual( 114return parameters1.SequenceEqual(parameters2, this.ParameterEquivalenceComparer);

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

203System.Linq.ImmutableArrayExtensions.SequenceEqual(_many, other._many, comparer);

CommandLine\CommonCompiler.ExistingReferencesResolver.cs (1)

80_availableReferences.SequenceEqual(other._availableReferences);

CommandLine\SarifDiagnosticComparer.cs (1)

56&& x.ImmutableCustomTags.SequenceEqual(y.ImmutableCustomTags);

CommandLine\SarifErrorLogger.cs (1)

88Debug.Assert(diagnostic.CustomTags.SequenceEqual(diagnostic.Descriptor.ImmutableCustomTags));

Compilation\CompilationOptions.cs (1)

630this.CryptoPublicKey.SequenceEqual(other.CryptoPublicKey) &&

Compilation\LoadDirective.cs (1)

31this.Diagnostics.SequenceEqual(other.Diagnostics);

Compilation\SymbolInfo.cs (1)

89CandidateSymbols.SequenceEqual(other.CandidateSymbols);

Desktop\DesktopAssemblyIdentityComparer.cs (3)

169!value.PublicKeyToken.SequenceEqual(identity.PublicKeyToken)) 258if (identity.PublicKeyToken.SequenceEqual(s_SILVERLIGHT_PLATFORM_PUBLICKEY_STR_L)) 270else if (identity.PublicKeyToken.SequenceEqual(s_SILVERLIGHT_PUBLICKEY_STR_L))

Desktop\DesktopAssemblyIdentityComparer.Fx.cs (1)

68&& this.PublicKeyToken.SequenceEqual(other.PublicKeyToken);

Emit\AnonymousTypeKey.cs (1)

76return (this.IsDelegate == other.IsDelegate) && this.Fields.SequenceEqual(other.Fields);

Emit\EditAndContinue\EncLambdaMapValue.cs (1)

37StructClosureIds.SequenceEqual(structClosureIds);

FileSystem\RelativePathResolver.cs (1)

61other is not null && BaseDirectory == other.BaseDirectory && SearchPaths.SequenceEqual(other.SearchPaths);

MetadataReference\AssemblyIdentity.cs (4)

492return xToken.SequenceEqual(yToken); 498return x._publicKey.SequenceEqual(y._publicKey); 504return x.PublicKeyToken.SequenceEqual(yToken); 508return xToken.SequenceEqual(y.PublicKeyToken);

MetadataReference\AssemblyIdentity.DisplayName.cs (1)

437if (hasPublicKey && hasPublicKeyToken && !identity.PublicKeyToken.SequenceEqual(publicKeyToken))

MetadataReference\MetadataReferenceProperties.cs (1)

166return Aliases.SequenceEqual(other.Aliases)

PEWriter\CustomDebugInfoWriter.cs (1)

324if (!s1.GetUsedNamespaces(context).SequenceEqual(s2.GetUsedNamespaces(context)))

PEWriter\MetadataWriter.PortablePdb.cs (1)

45x != null && y != null && Equals(x.Parent, y.Parent) && x.GetUsedNamespaces(_context).SequenceEqual(y.GetUsedNamespaces(_context));

SourceFileResolver.cs (2)

144_searchPaths.SequenceEqual(other._searchPaths, StringComparer.Ordinal) && 145_pathMap.SequenceEqual(other._pathMap);

SourceGeneration\Nodes\NodeStateTable.cs (1)

614if (!_states.SequenceEqual(entry._states))

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

203_many.SequenceEqual(other._many, comparer);

StrongName\DesktopStrongNameProvider.cs (1)

283if (!_keyFileSearchPaths.SequenceEqual(other._keyFileSearchPaths, StringComparer.Ordinal))

Symbols\Attributes\CommonAttributeDataComparer.cs (2)

43attr1.CommonConstructorArguments.SequenceEqual(attr2.CommonConstructorArguments, typedConstantComparer) && 44(_considerNamedArgumentsOrder ? attr1.NamedArguments.SequenceEqual(attr2.NamedArguments, namedArgumentComparer) : attr1.NamedArguments.SetEquals(attr2.NamedArguments, namedArgumentComparer));

Text\SourceText.cs (1)

1219return leftContentHash.SequenceEqual(rightContentHash);

src\roslyn\src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

61other is not null && BaseDirectory == other.BaseDirectory && SearchPaths.SequenceEqual(other.SearchPaths);

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

203_many.SequenceEqual(other._many, comparer);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (3)

368return SymbolSpecifications.SequenceEqual(other.SymbolSpecifications) 369&& NamingStyles.SequenceEqual(other.NamingStyles) 370&& Rules.NamingRules.SequenceEqual(other.Rules.NamingRules);

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

198&& ApplicableSymbolKindList.SequenceEqual(other.ApplicableSymbolKindList) 199&& ApplicableAccessibilityList.SequenceEqual(other.ApplicableAccessibilityList) 200&& RequiredModifierList.SequenceEqual(other.RequiredModifierList);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ImmutableArrayComparer.cs (1)

20=> x.SequenceEqual(y);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (2)

62return property1.Parameters.SequenceEqual( 114return parameters1.SequenceEqual(parameters2, this.ParameterEquivalenceComparer);

src\roslyn\src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

61other is not null && BaseDirectory == other.BaseDirectory && SearchPaths.SequenceEqual(other.SearchPaths);

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

203_many.SequenceEqual(other._many, comparer);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (3)

368return SymbolSpecifications.SequenceEqual(other.SymbolSpecifications) 369&& NamingStyles.SequenceEqual(other.NamingStyles) 370&& Rules.NamingRules.SequenceEqual(other.Rules.NamingRules);

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

198&& ApplicableSymbolKindList.SequenceEqual(other.ApplicableSymbolKindList) 199&& ApplicableAccessibilityList.SequenceEqual(other.ApplicableAccessibilityList) 200&& RequiredModifierList.SequenceEqual(other.RequiredModifierList);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ImmutableArrayComparer.cs (1)

20=> x.SequenceEqual(y);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (2)

62return property1.Parameters.SequenceEqual( 114return parameters1.SequenceEqual(parameters2, this.ParameterEquivalenceComparer);

src\roslyn\src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

61other is not null && BaseDirectory == other.BaseDirectory && SearchPaths.SequenceEqual(other.SearchPaths);

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

203_many.SequenceEqual(other._many, comparer);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (3)

368return SymbolSpecifications.SequenceEqual(other.SymbolSpecifications) 369&& NamingStyles.SequenceEqual(other.NamingStyles) 370&& Rules.NamingRules.SequenceEqual(other.Rules.NamingRules);

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

198&& ApplicableSymbolKindList.SequenceEqual(other.ApplicableSymbolKindList) 199&& ApplicableAccessibilityList.SequenceEqual(other.ApplicableAccessibilityList) 200&& RequiredModifierList.SequenceEqual(other.RequiredModifierList);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ImmutableArrayComparer.cs (1)

20=> x.SequenceEqual(y);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (2)

62return property1.Parameters.SequenceEqual( 114return parameters1.SequenceEqual(parameters2, this.ParameterEquivalenceComparer);

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

290if (!membersA.SequenceEqual(membersB))

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

368method1.Parameters.SequenceEqual(method2.Parameters, SymbolEquivalenceComparer.Instance.ParameterEquivalenceComparer);

Binder\Binder_Lookup.cs (2)

1411&& binderFileIdentifier.FilePathChecksumOpt.SequenceEqual(symbolFileIdentifier.FilePathChecksumOpt); 1577if (key.SequenceEqual(publicKey))

Binder\DecisionDagBuilder.cs (1)

4495return sequence.RemainingTests.SequenceEqual(other.RemainingTests);

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

1938_ => sourceSignature.ParameterRefKinds.SequenceEqual(targetSignature.ParameterRefKinds)

BoundTree\UnboundLambda.cs (1)

854lambdaSymbol.RefCustomModifiers.SequenceEqual(refCustomModifiers))

Compilation\CSharpCompilation.cs (2)

2541return x.ContentHash.SequenceEqual(y.ContentHash) && x.Position == y.Position; 3319Debug.Assert(methodBodyDiagnostics.Diagnostics.SequenceEqual(diagnostics));

CSharpCompilationOptions.cs (1)

777(this.Usings == null ? other.Usings == null : this.Usings.SequenceEqual(other.Usings, StringComparer.Ordinal) &&

Symbols\ArrayTypeSymbol.cs (2)

176if (this.Sizes.SequenceEqual(other.Sizes)) 187return !otherLowerBounds.IsDefault && thisLowerBounds.SequenceEqual(otherLowerBounds);

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (1)

742else if (!RefCustomModifiers.SequenceEqual(other.RefCustomModifiers))

Symbols\FunctionPointers\FunctionPointerParameterSymbol.cs (1)

62|| RefCustomModifiers.SequenceEqual(other.RefCustomModifiers))

Symbols\MemberSignatureComparer.cs (1)

832return SubstituteModifiers(typeMap1, customModifiers1).SequenceEqual(SubstituteModifiers(typeMap2, customModifiers2));

Symbols\Metadata\PE\PEParameterSymbol.cs (1)

870Debug.Assert(initialized == s_defaultStringHandlerAttributeIndexes || indexes == initialized || indexes.SequenceEqual(initialized));

Symbols\NamedTypeSymbol.cs (1)

1146return elementNames.IsDefault ? otherElementNames.IsDefault : !otherElementNames.IsDefault && elementNames.SequenceEqual(otherElementNames);

Symbols\SignatureOnlyParameterSymbol.cs (1)

126_refCustomModifiers.SequenceEqual(other._refCustomModifiers) &&

Symbols\Source\LambdaSymbol.cs (1)

400&& lambda._refCustomModifiers.SequenceEqual(_refCustomModifiers)

Symbols\Source\SourceNamespaceSymbol.AliasesAndUsings.cs (5)

37Debug.Assert(result.ExternAliases.SequenceEqual(calculated.ExternAliases)); 39Debug.Assert(result.Usings.SequenceEqual(calculated.Usings)); 215Debug.Assert(result.SequenceEqual(GetAliasesAndUsingsForAsserts(declarationSyntax).GetUsingNamespacesOrTypes(this, declarationSyntax, basesBeingResolved))); 598Debug.Assert(calculated.UsingAliases.SequenceEqual(result.UsingAliases)); 600Debug.Assert(calculated.UsingNamespacesOrTypes.SequenceEqual(result.UsingNamespacesOrTypes));

Symbols\Tuples\TupleTypeSymbol.cs (2)

874bool namesUnchanged = mergedNames.IsDefault ? TupleElementNames.IsDefault : mergedNames.SequenceEqual(TupleElementNames); 963return one.SequenceEqual(other);

Symbols\TypeUnification.cs (6)

55Debug.Assert(substituted1.CustomModifiers.SequenceEqual(substituted2.CustomModifiers)); 111if (TypeSymbol.Equals(t1.Type, t2.Type, TypeCompareKind.CLRSignatureCompareOptions) && t1.CustomModifiers.SequenceEqual(t2.CustomModifiers)) 132if (t2.TypeKind != t1.TypeKind || !t2.CustomModifiers.SequenceEqual(t1.CustomModifiers)) 149if (t2.TypeKind != t1.TypeKind || !t2.CustomModifiers.SequenceEqual(t1.CustomModifiers)) 162if (t2.TypeKind != t1.TypeKind || !t2.CustomModifiers.SequenceEqual(t1.CustomModifiers)) 224if (t1.CustomModifiers.SequenceEqual(t2.CustomModifiers))

Symbols\TypeWithAnnotations.cs (1)

359!this.CustomModifiers.SequenceEqual(other.CustomModifiers))

Utilities\InterceptableLocation.cs (1)

187&& _checksum.SequenceEqual(other._checksum)

Utilities\TypeUnionValueSet.cs (2)

356Debug.Assert(_typesInUnion.SequenceEqual(other._typesInUnion)); 383Debug.Assert(_typesInUnion.SequenceEqual(other._typesInUnion));

Utilities\ValueSetFactory.NumericValueSet.cs (1)

322this._intervals.SequenceEqual(other._intervals);

ConvertToExtension\ExtensionMethodEqualityComparer.cs (5)

39=> attributes1.SequenceEqual(attributes2, this); 54return x.ConstructorArguments.SequenceEqual(y.ConstructorArguments) && 55x.NamedArguments.SequenceEqual(y.NamedArguments); 103if (!x.ConstraintTypes.SequenceEqual(y.ConstraintTypes, s_equivalenceComparer.SignatureTypeEquivalenceComparer)) 136x.MethodTypeParameters.SequenceEqual(y.MethodTypeParameters, this);

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

203_many.SequenceEqual(other._many, comparer);

Symbols\SignatureComparer.cs (2)

62return property1.Parameters.SequenceEqual( 114return parameters1.SequenceEqual(parameters2, this.ParameterEquivalenceComparer);

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.MoveFileCodeAction.cs (1)

116if (builder.All(folders => !folders.SequenceEqual(defaultPathBasedOnCurrentFolder, PathUtilities.Comparer)))

Completion\CompletionHelper.cs (1)

74=> System.Linq.ImmutableArrayExtensions.SequenceEqual(item1.Tags, item2.Tags);

Completion\Providers\UnionCompletionItemComparer.cs (1)

21x is not null && y is not null && x.DisplayText == y.DisplayText && x.Tags.SequenceEqual(y.Tags);

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (3)

4956match.ConstructorArguments.SequenceEqual(attribute.ConstructorArguments, TypedConstantComparer.Instance) && 4957match.NamedArguments.SequenceEqual(attribute.NamedArguments, NamedArgumentComparer.Instance)) 6975TypedConstantKind.Array => x.Values.IsDefault || x.Values.SequenceEqual(y.Values, Instance),

EditAndContinue\CommittedSolution.cs (1)

441=> checksumAlgorithm == sourceText.ChecksumAlgorithm && sourceText.GetChecksum().SequenceEqual(requiredChecksum);

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (1)

196analysis.activeStatementSpans.SequenceEqual(activeStatementSpans))

EditAndContinue\PdbMatchingSourceTextProvider.cs (1)

155if (!text.GetChecksum().SequenceEqual(requiredChecksum))

FindUsages\DefinitionItem.DetachedDefinitionItem.cs (4)

55this.Tags.SequenceEqual(other.Tags) && 56this.DisplayParts.SequenceEqual(other.DisplayParts) && 57this.SourceSpans.SequenceEqual(other.SourceSpans) && 58this.MetadataLocations.SequenceEqual(other.MetadataLocations) &&

InheritanceMargin\InheritanceMarginItem.cs (2)

65this.DisplayTexts.SequenceEqual(other.DisplayTexts) && 66this.TargetItems.SequenceEqual(other.TargetItems);

NavigationBar\NavigationBarItems\RoslynNavigationBarItem.cs (1)

57ChildItems.SequenceEqual(other.ChildItems);

NavigationBar\NavigationBarItems\RoslynNavigationBarItem.SymbolItem.cs (1)

108if (!this.InDocumentInfo.Value.spans.SequenceEqual(other.InDocumentInfo!.Value.spans) ||

PdbSourceDocument\PdbSourceDocumentLoaderService.cs (1)

194if (ignoreChecksum || fileChecksum.SequenceEqual(sourceDocument.Checksum))

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

290if (!membersA.SequenceEqual(membersB))

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

368method1.Parameters.SequenceEqual(method2.Parameters, SymbolEquivalenceComparer.Instance.ParameterEquivalenceComparer);

Language\RazorConfiguration.cs (2)

47PreprocessorSymbols.SequenceEqual(other.PreprocessorSymbols) && 48Extensions.SequenceEqual(other.Extensions);

Language\RazorParserOptions.cs (2)

104=> Directives.SequenceEqual(value) 196&& Directives.SequenceEqual(other.Directives, ReferenceEqualityComparer<DirectiveDescriptor>.Instance);

SourceGenerators\RazorSourceGenerator.cs (2)

84.WithLambdaComparer((old, @new) => old.Right.Equals(@new.Right) && old.Left.Left.Equals(@new.Left.Left) && old.Left.Right.SequenceEqual(@new.Left.Right)) 251.WithLambdaComparer((old, @new) => old.Left.Equals(@new.Left) && old.Right.SequenceEqual(@new.Right))

SourceGenerators\SourceGeneratorProjectItem.cs (1)

81return thisHash.SequenceEqual(otherHash);

CompilationOptionsReader.cs (1)

314if (!sourceText.GetChecksum().SequenceEqual(sourceTextInfo.Hash))

src\roslyn\src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

61other is not null && BaseDirectory == other.BaseDirectory && SearchPaths.SequenceEqual(other.SearchPaths);

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

203_many.SequenceEqual(other._many, comparer);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (3)

368return SymbolSpecifications.SequenceEqual(other.SymbolSpecifications) 369&& NamingStyles.SequenceEqual(other.NamingStyles) 370&& Rules.NamingRules.SequenceEqual(other.Rules.NamingRules);

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

198&& ApplicableSymbolKindList.SequenceEqual(other.ApplicableSymbolKindList) 199&& ApplicableAccessibilityList.SequenceEqual(other.ApplicableAccessibilityList) 200&& RequiredModifierList.SequenceEqual(other.RequiredModifierList);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ImmutableArrayComparer.cs (1)

20=> x.SequenceEqual(y);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (2)

62return property1.Parameters.SequenceEqual( 114return parameters1.SequenceEqual(parameters2, this.ParameterEquivalenceComparer);

src\roslyn\src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

61other is not null && BaseDirectory == other.BaseDirectory && SearchPaths.SequenceEqual(other.SearchPaths);

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

89Architectures.SequenceEqual(other.Architectures) &&

LinkedFileDiffMerging\LinkedFileDiffMergingSession.cs (1)

43if (newDocumentsAndHashes.Any(t => t.newContentHash.SequenceEqual(newContentHash)))

Rename\ConflictEngine\DeclarationConflictHelpers.cs (1)

86=> x.SequenceEqual(y);

Shared\Extensions\SemanticModelExtensions.cs (1)

63.FirstOrDefault(s => s.Parameters.SequenceEqual(methodSymbol.Parameters, comparer));

src\roslyn\src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

61other is not null && BaseDirectory == other.BaseDirectory && SearchPaths.SequenceEqual(other.SearchPaths);

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

203_many.SequenceEqual(other._many, comparer);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (3)

368return SymbolSpecifications.SequenceEqual(other.SymbolSpecifications) 369&& NamingStyles.SequenceEqual(other.NamingStyles) 370&& Rules.NamingRules.SequenceEqual(other.Rules.NamingRules);

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

198&& ApplicableSymbolKindList.SequenceEqual(other.ApplicableSymbolKindList) 199&& ApplicableAccessibilityList.SequenceEqual(other.ApplicableAccessibilityList) 200&& RequiredModifierList.SequenceEqual(other.RequiredModifierList);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ImmutableArrayComparer.cs (1)

20=> x.SequenceEqual(y);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (2)

62return property1.Parameters.SequenceEqual( 114return parameters1.SequenceEqual(parameters2, this.ParameterEquivalenceComparer);

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (1)

760convertedProject.ProjectReference.Aliases.SequenceEqual(properties.Aliases))

Workspace\Solution\ProjectReference.cs (1)

52Aliases.SequenceEqual(reference.Aliases) &&

Workspace\Solution\ProjectState.cs (3)

974Debug.Assert(!oldDocuments.SequenceEqual(newDocuments)); 1000Debug.Assert(!oldDocuments.SequenceEqual(newDocuments)); 1023Debug.Assert(!oldDocuments.SequenceEqual(newDocuments));

Workspace\Solution\SolutionCompilationState.TranslationAction_Actions.cs (2)

59priorTouchAction._newStates.SequenceEqual(_oldStates)) 91priorTouchAction._newStates.SequenceEqual(_oldStates))

Comparing\TypedConstantEqualityComparer.cs (1)

26if (!x.Values.SequenceEqual(y.Values, this))

Signing.cs (1)

195if (!assemblyPublicKey.SequenceEqual(snkPublicKey))

Comparers.cs (1)

40return x.SequenceEqual(y, _elementComparer);

Comparers.cs (1)

32return x.SequenceEqual(y, _elementComparer);

ContainingSyntaxContext.cs (1)

88return ContainingSyntax.SequenceEqual(other.ContainingSyntax)

MethodSignatureDiagnosticLocations.cs (1)

64&& ManagedParameterLocations.SequenceEqual(other.ManagedParameterLocations)

SequenceEqualImmutableArray.cs (1)

40return Array.SequenceEqual(other.Array, Comparer);

SignatureContext.cs (2)

139&& ElementTypeInformation.SequenceEqual(other.ElementTypeInformation) 141&& AdditionalAttributes.SequenceEqual(other.AdditionalAttributes, (IEqualityComparer<AttributeListSyntax>)SyntaxEquivalentComparer.Instance);

Transformers\NormalizerTests.cs (1)

1066Assert.True(dimensions1.SequenceEqual(dimensions2));

AbstractApplyTraitToClass`1.cs (1)

108if (!expectedAttributeData.ConstructorArguments.SequenceEqual(actualAttributeData.ConstructorArguments))

src\roslyn\src\Compilers\Core\Portable\FileSystem\RelativePathResolver.cs (1)

61other is not null && BaseDirectory == other.BaseDirectory && SearchPaths.SequenceEqual(other.SearchPaths);

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

203_many.SequenceEqual(other._many, comparer);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\NamingStylePreferences.cs (3)

368return SymbolSpecifications.SequenceEqual(other.SymbolSpecifications) 369&& NamingStyles.SequenceEqual(other.NamingStyles) 370&& Rules.NamingRules.SequenceEqual(other.Rules.NamingRules);

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

198&& ApplicableSymbolKindList.SequenceEqual(other.ApplicableSymbolKindList) 199&& ApplicableAccessibilityList.SequenceEqual(other.ApplicableAccessibilityList) 200&& RequiredModifierList.SequenceEqual(other.RequiredModifierList);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ImmutableArrayComparer.cs (1)

20=> x.SequenceEqual(y);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (2)

62return property1.Parameters.SequenceEqual( 114return parameters1.SequenceEqual(parameters2, this.ParameterEquivalenceComparer);

System\Windows\Forms\SourceGenerators\EquatableArray`1.cs (1)

33return Values.SequenceEqual(other.Values);