Use sets for include expressions

Bart Koelman · Bart Koelman · commit 4e3c5e85b6b8 · 2021-10-06T16:51:01.000+02:00
diff --git a/benchmarks/Serialization/SerializationBenchmarkBase.cs b/benchmarks/Serialization/SerializationBenchmarkBase.cs
@@ -130,7 +130,7 @@ public sealed class ResourceA : Identifiable
 
         private sealed class FakeResourceDefinitionAccessor : IResourceDefinitionAccessor
         {
-            public IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<IncludeElementExpression> existingIncludes)
+            public IImmutableSet<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableSet<IncludeElementExpression> existingIncludes)
             {
                 return existingIncludes;
             }
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IncludeChainConverter.cs b/src/JsonApiDotNetCore/Queries/Expressions/IncludeChainConverter.cs
@@ -68,11 +68,11 @@ public IncludeExpression FromRelationshipChains(IEnumerable<ResourceFieldChainEx
         {
             ArgumentGuard.NotNull(chains, nameof(chains));
 
-            IImmutableList<IncludeElementExpression> elements = ConvertChainsToElements(chains);
+            IImmutableSet<IncludeElementExpression> elements = ConvertChainsToElements(chains);
             return elements.Any() ? new IncludeExpression(elements) : IncludeExpression.Empty;
         }
 
-        private static IImmutableList<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)
+        private static IImmutableSet<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)
         {
             var rootNode = new MutableIncludeNode(null);
 
@@ -81,7 +81,7 @@ private static IImmutableList<IncludeElementExpression> ConvertChainsToElements(
                 ConvertChainToElement(chain, rootNode);
             }
 
-            return rootNode.Children.Values.Select(child => child.ToExpression()).ToImmutableArray();
+            return rootNode.Children.Values.Select(child => child.ToExpression()).ToImmutableHashSet();
         }
 
         private static void ConvertChainToElement(ResourceFieldChainExpression chain, MutableIncludeNode rootNode)
@@ -161,7 +161,7 @@ public MutableIncludeNode(RelationshipAttribute relationship)
 
             public IncludeElementExpression ToExpression()
             {
-                ImmutableArray<IncludeElementExpression> elementChildren = Children.Values.Select(child => child.ToExpression()).ToImmutableArray();
+                IImmutableSet<IncludeElementExpression> elementChildren = Children.Values.Select(child => child.ToExpression()).ToImmutableHashSet();
                 return new IncludeElementExpression(_relationship, elementChildren);
             }
         }
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IncludeElementExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/IncludeElementExpression.cs
@@ -14,14 +14,14 @@ namespace JsonApiDotNetCore.Queries.Expressions
     public class IncludeElementExpression : QueryExpression
     {
         public RelationshipAttribute Relationship { get; }
-        public IImmutableList<IncludeElementExpression> Children { get; }
+        public IImmutableSet<IncludeElementExpression> Children { get; }
 
         public IncludeElementExpression(RelationshipAttribute relationship)
-            : this(relationship, ImmutableArray<IncludeElementExpression>.Empty)
+            : this(relationship, ImmutableHashSet<IncludeElementExpression>.Empty)
         {
         }
 
-        public IncludeElementExpression(RelationshipAttribute relationship, IImmutableList<IncludeElementExpression> children)
+        public IncludeElementExpression(RelationshipAttribute relationship, IImmutableSet<IncludeElementExpression> children)
         {
             ArgumentGuard.NotNull(relationship, nameof(relationship));
             ArgumentGuard.NotNull(children, nameof(children));
@@ -43,7 +43,7 @@ public override string ToString()
             if (Children.Any())
             {
                 builder.Append('{');
-                builder.Append(string.Join(",", Children.Select(child => child.ToString())));
+                builder.Append(string.Join(",", Children.Select(child => child.ToString()).OrderBy(name => name)));
                 builder.Append('}');
             }
 
@@ -64,7 +64,7 @@ public override bool Equals(object obj)
 
             var other = (IncludeElementExpression)obj;
 
-            return Relationship.Equals(other.Relationship) && Children.SequenceEqual(other.Children);
+            return Relationship.Equals(other.Relationship) && Children.SetEquals(other.Children);
         }
 
         public override int GetHashCode()
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IncludeExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/IncludeExpression.cs
@@ -16,9 +16,9 @@ public class IncludeExpression : QueryExpression
 
         public static readonly IncludeExpression Empty = new();
 
-        public IImmutableList<IncludeElementExpression> Elements { get; }
+        public IImmutableSet<IncludeElementExpression> Elements { get; }
 
-        public IncludeExpression(IImmutableList<IncludeElementExpression> elements)
+        public IncludeExpression(IImmutableSet<IncludeElementExpression> elements)
         {
             ArgumentGuard.NotNullNorEmpty(elements, nameof(elements));
 
@@ -27,7 +27,7 @@ public IncludeExpression(IImmutableList<IncludeElementExpression> elements)
 
         private IncludeExpression()
         {
-            Elements = ImmutableArray<IncludeElementExpression>.Empty;
+            Elements = ImmutableHashSet<IncludeElementExpression>.Empty;
         }
 
         public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)
@@ -38,7 +38,7 @@ public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgum
         public override string ToString()
         {
             IReadOnlyCollection<ResourceFieldChainExpression> chains = IncludeChainConverter.GetRelationshipChains(this);
-            return string.Join(",", chains.Select(child => child.ToString()));
+            return string.Join(",", chains.Select(child => child.ToString()).OrderBy(name => name));
         }
 
         public override bool Equals(object obj)
@@ -55,7 +55,7 @@ public override bool Equals(object obj)
 
             var other = (IncludeExpression)obj;
 
-            return Elements.SequenceEqual(other.Elements);
+            return Elements.SetEquals(other.Elements);
         }
 
         public override int GetHashCode()
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs b/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs
@@ -268,7 +268,7 @@ public override QueryExpression VisitInclude(IncludeExpression expression, TArgu
         {
             if (expression != null)
             {
-                IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Elements, argument);
+                IImmutableSet<IncludeElementExpression> newElements = VisitSet(expression.Elements, argument);
 
                 if (newElements.Count == 0)
                 {
@@ -286,7 +286,7 @@ public override QueryExpression VisitIncludeElement(IncludeElementExpression exp
         {
             if (expression != null)
             {
-                IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Children, argument);
+                IImmutableSet<IncludeElementExpression> newElements = VisitSet(expression.Children, argument);
 
                 var newExpression = new IncludeElementExpression(expression.Relationship, newElements);
                 return newExpression.Equals(expression) ? expression : newExpression;
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs
@@ -131,21 +131,21 @@ private IncludeExpression ComposeChildren(QueryLayer topLayer, ICollection<Expre
             // @formatter:keep_existing_linebreaks restore
             // @formatter:wrap_chained_method_calls restore
 
-            IImmutableList<IncludeElementExpression> includeElements =
+            IImmutableSet<IncludeElementExpression> includeElements =
                 ProcessIncludeSet(include.Elements, topLayer, new List<RelationshipAttribute>(), constraints);
 
             return !ReferenceEquals(includeElements, include.Elements)
                 ? includeElements.Any() ? new IncludeExpression(includeElements) : IncludeExpression.Empty
                 : include;
         }
 
-        private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableList<IncludeElementExpression> includeElements, QueryLayer parentLayer,
+        private IImmutableSet<IncludeElementExpression> ProcessIncludeSet(IImmutableSet<IncludeElementExpression> includeElements, QueryLayer parentLayer,
             ICollection<RelationshipAttribute> parentRelationshipChain, ICollection<ExpressionInScope> constraints)
         {
-            IImmutableList<IncludeElementExpression> includeElementsEvaluated =
-                GetIncludeElements(includeElements, parentLayer.ResourceContext) ?? ImmutableArray<IncludeElementExpression>.Empty;
+            IImmutableSet<IncludeElementExpression> includeElementsEvaluated =
+                GetIncludeElements(includeElements, parentLayer.ResourceContext) ?? ImmutableHashSet<IncludeElementExpression>.Empty;
 
-            var updatesInChildren = new Dictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>>();
+            var updatesInChildren = new Dictionary<IncludeElementExpression, IImmutableSet<IncludeElementExpression>>();
 
             foreach (IncludeElementExpression includeElement in includeElementsEvaluated)
             {
@@ -187,7 +187,7 @@ private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableLis
 
                     if (includeElement.Children.Any())
                     {
-                        IImmutableList<IncludeElementExpression> updatedChildren =
+                        IImmutableSet<IncludeElementExpression> updatedChildren =
                             ProcessIncludeSet(includeElement.Children, child, relationshipChain, constraints);
 
                         if (!ReferenceEquals(includeElement.Children, updatedChildren))
@@ -201,16 +201,16 @@ private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableLis
             return !updatesInChildren.Any() ? includeElementsEvaluated : ApplyIncludeElementUpdates(includeElementsEvaluated, updatesInChildren);
         }
 
-        private static IImmutableList<IncludeElementExpression> ApplyIncludeElementUpdates(IImmutableList<IncludeElementExpression> includeElements,
-            IDictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>> updatesInChildren)
+        private static IImmutableSet<IncludeElementExpression> ApplyIncludeElementUpdates(IImmutableSet<IncludeElementExpression> includeElements,
+            IDictionary<IncludeElementExpression, IImmutableSet<IncludeElementExpression>> updatesInChildren)
         {
-            ImmutableArray<IncludeElementExpression>.Builder newElementsBuilder = ImmutableArray.CreateBuilder<IncludeElementExpression>(includeElements.Count);
+            ImmutableHashSet<IncludeElementExpression>.Builder newElementsBuilder = ImmutableHashSet.CreateBuilder<IncludeElementExpression>();
             newElementsBuilder.AddRange(includeElements);
 
-            foreach ((IncludeElementExpression existingElement, IImmutableList<IncludeElementExpression> updatedChildren) in updatesInChildren)
+            foreach ((IncludeElementExpression existingElement, IImmutableSet<IncludeElementExpression> updatedChildren) in updatesInChildren)
             {
-                int existingIndex = newElementsBuilder.IndexOf(existingElement);
-                newElementsBuilder[existingIndex] = new IncludeElementExpression(existingElement.Relationship, updatedChildren);
+                newElementsBuilder.Remove(existingElement);
+                newElementsBuilder.Add(new IncludeElementExpression(existingElement.Relationship, updatedChildren));
             }
 
             return newElementsBuilder.ToImmutable();
@@ -301,7 +301,7 @@ private IncludeExpression RewriteIncludeForSecondaryEndpoint(IncludeExpression r
                 ? new IncludeElementExpression(secondaryRelationship, relativeInclude.Elements)
                 : new IncludeElementExpression(secondaryRelationship);
 
-            return new IncludeExpression(ImmutableArray.Create(parentElement));
+            return new IncludeExpression(ImmutableHashSet.Create(parentElement));
         }
 
         private FilterExpression CreateFilterByIds<TId>(IReadOnlyCollection<TId> ids, AttrAttribute idAttribute, FilterExpression existingFilter)
@@ -329,8 +329,8 @@ public QueryLayer ComposeForUpdate<TId>(TId id, ResourceContext primaryResource)
         {
             ArgumentGuard.NotNull(primaryResource, nameof(primaryResource));
 
-            ImmutableArray<IncludeElementExpression> includeElements = _targetedFields.Relationships
-                .Select(relationship => new IncludeElementExpression(relationship)).ToImmutableArray();
+            IImmutableSet<IncludeElementExpression> includeElements = _targetedFields.Relationships
+                .Select(relationship => new IncludeElementExpression(relationship)).ToImmutableHashSet();
 
             AttrAttribute primaryIdAttribute = GetIdAttribute(primaryResource);
 
@@ -405,7 +405,7 @@ public QueryLayer ComposeForHasMany<TId>(HasManyAttribute hasManyRelationship, T
 
             return new QueryLayer(leftResourceContext)
             {
-                Include = new IncludeExpression(ImmutableArray.Create(new IncludeElementExpression(hasManyRelationship))),
+                Include = new IncludeExpression(ImmutableHashSet.Create(new IncludeElementExpression(hasManyRelationship))),
                 Filter = leftFilter,
                 Projection = new Dictionary<ResourceFieldAttribute, QueryLayer>
                 {
@@ -422,7 +422,7 @@ public QueryLayer ComposeForHasMany<TId>(HasManyAttribute hasManyRelationship, T
             };
         }
 
-        protected virtual IImmutableList<IncludeElementExpression> GetIncludeElements(IImmutableList<IncludeElementExpression> includeElements,
+        protected virtual IImmutableSet<IncludeElementExpression> GetIncludeElements(IImmutableSet<IncludeElementExpression> includeElements,
             ResourceContext resourceContext)
         {
             ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
diff --git a/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs b/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs
@@ -44,7 +44,7 @@ public interface IResourceDefinition<TResource, in TId>
         /// <returns>
         /// The new set of includes. Return an empty collection to remove all inclusions (never return <c>null</c>).
         /// </returns>
-        IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes);
+        IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes);
 
         /// <summary>
         /// Enables to extend, replace or remove a filter that is being applied on a set of this resource type.
diff --git a/src/JsonApiDotNetCore/Resources/IResourceDefinitionAccessor.cs b/src/JsonApiDotNetCore/Resources/IResourceDefinitionAccessor.cs
@@ -18,7 +18,7 @@ public interface IResourceDefinitionAccessor
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnApplyIncludes" /> for the specified resource type.
         /// </summary>
-        IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<IncludeElementExpression> existingIncludes);
+        IImmutableSet<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableSet<IncludeElementExpression> existingIncludes);
 
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnApplyFilter" /> for the specified resource type.
diff --git a/src/JsonApiDotNetCore/Resources/JsonApiResourceDefinition.cs b/src/JsonApiDotNetCore/Resources/JsonApiResourceDefinition.cs
@@ -52,7 +52,7 @@ public JsonApiResourceDefinition(IResourceGraph resourceGraph)
         }
 
         /// <inheritdoc />
-        public virtual IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)
+        public virtual IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes)
         {
             return existingIncludes;
         }
diff --git a/src/JsonApiDotNetCore/Resources/ResourceDefinitionAccessor.cs b/src/JsonApiDotNetCore/Resources/ResourceDefinitionAccessor.cs
@@ -29,7 +29,7 @@ public ResourceDefinitionAccessor(IResourceGraph resourceGraph, IServiceProvider
         }
 
         /// <inheritdoc />
-        public IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<IncludeElementExpression> existingIncludes)
+        public IImmutableSet<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableSet<IncludeElementExpression> existingIncludes)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
diff --git a/src/JsonApiDotNetCore/Serialization/ResponseModelAdapter.cs b/src/JsonApiDotNetCore/Serialization/ResponseModelAdapter.cs
@@ -65,7 +65,7 @@ public Document Convert(object model)
             var document = new Document();
 
             IncludeExpression include = _evaluatedIncludeCache.Get();
-            IImmutableList<IncludeElementExpression> includeElements = include?.Elements ?? ImmutableArray<IncludeElementExpression>.Empty;
+            IImmutableSet<IncludeElementExpression> includeElements = include?.Elements ?? ImmutableHashSet<IncludeElementExpression>.Empty;
 
             var includedCollection = new IncludedCollection();
 
@@ -111,7 +111,7 @@ public Document Convert(object model)
             return document;
         }
 
-        private AtomicResultObject ConvertOperation(OperationContainer operation, IImmutableList<IncludeElementExpression> includeElements,
+        private AtomicResultObject ConvertOperation(OperationContainer operation, IImmutableSet<IncludeElementExpression> includeElements,
             IncludedCollection includedCollection)
         {
             ResourceObject resourceObject = null;
@@ -131,7 +131,7 @@ private AtomicResultObject ConvertOperation(OperationContainer operation, IImmut
             };
         }
 
-        private ResourceObject ConvertResource(IIdentifiable resource, EndpointKind requestKind, IImmutableList<IncludeElementExpression> includeElements,
+        private ResourceObject ConvertResource(IIdentifiable resource, EndpointKind requestKind, IImmutableSet<IncludeElementExpression> includeElements,
             IncludedCollection includedCollection, bool isInclude)
         {
             ResourceContext resourceContext = _resourceGraph.GetResourceContext(resource.GetType());
@@ -203,7 +203,7 @@ private IDictionary<string, object> ConvertAttributes(IIdentifiable resource, Re
         }
 
         private IDictionary<string, RelationshipObject> ConvertRelationships(IIdentifiable resource, ResourceContext resourceContext,
-            IImmutableSet<ResourceFieldAttribute> fieldSet, EndpointKind requestKind, IImmutableList<IncludeElementExpression> includeElements,
+            IImmutableSet<ResourceFieldAttribute> fieldSet, EndpointKind requestKind, IImmutableSet<IncludeElementExpression> includeElements,
             IncludedCollection includedCollection)
         {
             if (fieldSet != null)
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs
@@ -25,7 +25,7 @@ public MoonDefinition(IResourceGraph resourceGraph, IClientSettingsProvider clie
             _hitCounter = hitCounter;
         }
 
-        public override IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)
+        public override IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes)
         {
             _hitCounter.TrackInvocation<Moon>(ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes);
 
diff --git a/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/PlanetDefinition.cs b/test/JsonApiDotNetCoreTests/IntegrationTests/ResourceDefinitions/Reading/PlanetDefinition.cs
@@ -27,7 +27,7 @@ public PlanetDefinition(IResourceGraph resourceGraph, IClientSettingsProvider cl
             _hitCounter = hitCounter;
         }
 
-        public override IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)
+        public override IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes)
         {
             _hitCounter.TrackInvocation<Planet>(ResourceDefinitionHitCounter.ExtensibilityPoint.OnApplyIncludes);
 
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/IncludeParseTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/QueryStringParameters/IncludeParseTests.cs
@@ -82,7 +82,7 @@ public void Reader_Read_Fails(string parameterName, string parameterValue, strin
         [InlineData("includes", "posts.author", "posts.author")]
         [InlineData("includes", "posts.comments", "posts.comments")]
         [InlineData("includes", "posts,posts.comments", "posts.comments")]
-        [InlineData("includes", "posts,posts.comments,posts.labels", "posts.comments,posts.labels")]
+        [InlineData("includes", "posts,posts.labels,posts.comments", "posts.comments,posts.labels")]
         public void Reader_Read_Succeeds(string parameterName, string parameterValue, string valueExpected)
         {
             // Act
diff --git a/test/UnitTests/Extensions/ServiceCollectionExtensionsTests.cs b/test/UnitTests/Extensions/ServiceCollectionExtensionsTests.cs

Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,7 @@ public sealed class ResourceA : Identifiable`
`130`	`130`
`131`	`131`	`private sealed class FakeResourceDefinitionAccessor : IResourceDefinitionAccessor`
`132`	`132`	`{`
`133`		`- public IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<IncludeElementExpression> existingIncludes)`
	`133`	`+ public IImmutableSet<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableSet<IncludeElementExpression> existingIncludes)`
`134`	`134`	`{`
`135`	`135`	`return existingIncludes;`
`136`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,11 +68,11 @@ public IncludeExpression FromRelationshipChains(IEnumerable<ResourceFieldChainEx`
`68`	`68`	`{`
`69`	`69`	`ArgumentGuard.NotNull(chains, nameof(chains));`
`70`	`70`
`71`		`- IImmutableList<IncludeElementExpression> elements = ConvertChainsToElements(chains);`
	`71`	`+ IImmutableSet<IncludeElementExpression> elements = ConvertChainsToElements(chains);`
`72`	`72`	`return elements.Any() ? new IncludeExpression(elements) : IncludeExpression.Empty;`
`73`	`73`	`}`
`74`	`74`
`75`		`- private static IImmutableList<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)`
	`75`	`+ private static IImmutableSet<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)`
`76`	`76`	`{`
`77`	`77`	`var rootNode = new MutableIncludeNode(null);`
`78`	`78`
`@@ -81,7 +81,7 @@ private static IImmutableList<IncludeElementExpression> ConvertChainsToElements(`
`81`	`81`	`ConvertChainToElement(chain, rootNode);`
`82`	`82`	`}`
`83`	`83`
`84`		`- return rootNode.Children.Values.Select(child => child.ToExpression()).ToImmutableArray();`
	`84`	`+ return rootNode.Children.Values.Select(child => child.ToExpression()).ToImmutableHashSet();`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`private static void ConvertChainToElement(ResourceFieldChainExpression chain, MutableIncludeNode rootNode)`
`@@ -161,7 +161,7 @@ public MutableIncludeNode(RelationshipAttribute relationship)`
`161`	`161`
`162`	`162`	`public IncludeElementExpression ToExpression()`
`163`	`163`	`{`
`164`		`- ImmutableArray<IncludeElementExpression> elementChildren = Children.Values.Select(child => child.ToExpression()).ToImmutableArray();`
	`164`	`+ IImmutableSet<IncludeElementExpression> elementChildren = Children.Values.Select(child => child.ToExpression()).ToImmutableHashSet();`
`165`	`165`	`return new IncludeElementExpression(_relationship, elementChildren);`
`166`	`166`	`}`
`167`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,14 +14,14 @@ namespace JsonApiDotNetCore.Queries.Expressions`
`14`	`14`	`public class IncludeElementExpression : QueryExpression`
`15`	`15`	`{`
`16`	`16`	`public RelationshipAttribute Relationship { get; }`
`17`		`- public IImmutableList<IncludeElementExpression> Children { get; }`
	`17`	`+ public IImmutableSet<IncludeElementExpression> Children { get; }`
`18`	`18`
`19`	`19`	`public IncludeElementExpression(RelationshipAttribute relationship)`
`20`		`- : this(relationship, ImmutableArray<IncludeElementExpression>.Empty)`
	`20`	`+ : this(relationship, ImmutableHashSet<IncludeElementExpression>.Empty)`
`21`	`21`	`{`
`22`	`22`	`}`
`23`	`23`
`24`		`- public IncludeElementExpression(RelationshipAttribute relationship, IImmutableList<IncludeElementExpression> children)`
	`24`	`+ public IncludeElementExpression(RelationshipAttribute relationship, IImmutableSet<IncludeElementExpression> children)`
`25`	`25`	`{`
`26`	`26`	`ArgumentGuard.NotNull(relationship, nameof(relationship));`
`27`	`27`	`ArgumentGuard.NotNull(children, nameof(children));`
`@@ -43,7 +43,7 @@ public override string ToString()`
`43`	`43`	`if (Children.Any())`
`44`	`44`	`{`
`45`	`45`	`builder.Append('{');`
`46`		`- builder.Append(string.Join(",", Children.Select(child => child.ToString())));`
	`46`	`+ builder.Append(string.Join(",", Children.Select(child => child.ToString()).OrderBy(name => name)));`
`47`	`47`	`builder.Append('}');`
`48`	`48`	`}`
`49`	`49`
`@@ -64,7 +64,7 @@ public override bool Equals(object obj)`
`64`	`64`
`65`	`65`	`var other = (IncludeElementExpression)obj;`
`66`	`66`
`67`		`- return Relationship.Equals(other.Relationship) && Children.SequenceEqual(other.Children);`
	`67`	`+ return Relationship.Equals(other.Relationship) && Children.SetEquals(other.Children);`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`public override int GetHashCode()`
Original file line number	Diff line number	Diff line change
`@@ -16,9 +16,9 @@ public class IncludeExpression : QueryExpression`
`16`	`16`
`17`	`17`	`public static readonly IncludeExpression Empty = new();`
`18`	`18`
`19`		`- public IImmutableList<IncludeElementExpression> Elements { get; }`
	`19`	`+ public IImmutableSet<IncludeElementExpression> Elements { get; }`
`20`	`20`
`21`		`- public IncludeExpression(IImmutableList<IncludeElementExpression> elements)`
	`21`	`+ public IncludeExpression(IImmutableSet<IncludeElementExpression> elements)`
`22`	`22`	`{`
`23`	`23`	`ArgumentGuard.NotNullNorEmpty(elements, nameof(elements));`
`24`	`24`
`@@ -27,7 +27,7 @@ public IncludeExpression(IImmutableList<IncludeElementExpression> elements)`
`27`	`27`
`28`	`28`	`private IncludeExpression()`
`29`	`29`	`{`
`30`		`- Elements = ImmutableArray<IncludeElementExpression>.Empty;`
	`30`	`+ Elements = ImmutableHashSet<IncludeElementExpression>.Empty;`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)`
`@@ -38,7 +38,7 @@ public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgum`
`38`	`38`	`public override string ToString()`
`39`	`39`	`{`
`40`	`40`	`IReadOnlyCollection<ResourceFieldChainExpression> chains = IncludeChainConverter.GetRelationshipChains(this);`
`41`		`- return string.Join(",", chains.Select(child => child.ToString()));`
	`41`	`+ return string.Join(",", chains.Select(child => child.ToString()).OrderBy(name => name));`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public override bool Equals(object obj)`
`@@ -55,7 +55,7 @@ public override bool Equals(object obj)`
`55`	`55`
`56`	`56`	`var other = (IncludeExpression)obj;`
`57`	`57`
`58`		`- return Elements.SequenceEqual(other.Elements);`
	`58`	`+ return Elements.SetEquals(other.Elements);`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`public override int GetHashCode()`
Original file line number	Diff line number	Diff line change
`@@ -268,7 +268,7 @@ public override QueryExpression VisitInclude(IncludeExpression expression, TArgu`
`268`	`268`	`{`
`269`	`269`	`if (expression != null)`
`270`	`270`	`{`
`271`		`- IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Elements, argument);`
	`271`	`+ IImmutableSet<IncludeElementExpression> newElements = VisitSet(expression.Elements, argument);`
`272`	`272`
`273`	`273`	`if (newElements.Count == 0)`
`274`	`274`	`{`
`@@ -286,7 +286,7 @@ public override QueryExpression VisitIncludeElement(IncludeElementExpression exp`
`286`	`286`	`{`
`287`	`287`	`if (expression != null)`
`288`	`288`	`{`
`289`		`- IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Children, argument);`
	`289`	`+ IImmutableSet<IncludeElementExpression> newElements = VisitSet(expression.Children, argument);`
`290`	`290`
`291`	`291`	`var newExpression = new IncludeElementExpression(expression.Relationship, newElements);`
`292`	`292`	`return newExpression.Equals(expression) ? expression : newExpression;`
Original file line number	Diff line number	Diff line change
`@@ -131,21 +131,21 @@ private IncludeExpression ComposeChildren(QueryLayer topLayer, ICollection<Expre`
`131`	`131`	`// @formatter:keep_existing_linebreaks restore`
`132`	`132`	`// @formatter:wrap_chained_method_calls restore`
`133`	`133`
`134`		`- IImmutableList<IncludeElementExpression> includeElements =`
	`134`	`+ IImmutableSet<IncludeElementExpression> includeElements =`
`135`	`135`	`ProcessIncludeSet(include.Elements, topLayer, new List<RelationshipAttribute>(), constraints);`
`136`	`136`
`137`	`137`	`return !ReferenceEquals(includeElements, include.Elements)`
`138`	`138`	`? includeElements.Any() ? new IncludeExpression(includeElements) : IncludeExpression.Empty`
`139`	`139`	`: include;`
`140`	`140`	`}`
`141`	`141`
`142`		`- private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableList<IncludeElementExpression> includeElements, QueryLayer parentLayer,`
	`142`	`+ private IImmutableSet<IncludeElementExpression> ProcessIncludeSet(IImmutableSet<IncludeElementExpression> includeElements, QueryLayer parentLayer,`
`143`	`143`	`ICollection<RelationshipAttribute> parentRelationshipChain, ICollection<ExpressionInScope> constraints)`
`144`	`144`	`{`
`145`		`- IImmutableList<IncludeElementExpression> includeElementsEvaluated =`
`146`		`- GetIncludeElements(includeElements, parentLayer.ResourceContext) ?? ImmutableArray<IncludeElementExpression>.Empty;`
	`145`	`+ IImmutableSet<IncludeElementExpression> includeElementsEvaluated =`
	`146`	`+ GetIncludeElements(includeElements, parentLayer.ResourceContext) ?? ImmutableHashSet<IncludeElementExpression>.Empty;`
`147`	`147`
`148`		`- var updatesInChildren = new Dictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>>();`
	`148`	`+ var updatesInChildren = new Dictionary<IncludeElementExpression, IImmutableSet<IncludeElementExpression>>();`
`149`	`149`
`150`	`150`	`foreach (IncludeElementExpression includeElement in includeElementsEvaluated)`
`151`	`151`	`{`
`@@ -187,7 +187,7 @@ private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableLis`
`187`	`187`
`188`	`188`	`if (includeElement.Children.Any())`
`189`	`189`	`{`
`190`		`- IImmutableList<IncludeElementExpression> updatedChildren =`
	`190`	`+ IImmutableSet<IncludeElementExpression> updatedChildren =`
`191`	`191`	`ProcessIncludeSet(includeElement.Children, child, relationshipChain, constraints);`
`192`	`192`
`193`	`193`	`if (!ReferenceEquals(includeElement.Children, updatedChildren))`
`@@ -201,16 +201,16 @@ private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableLis`
`201`	`201`	`return !updatesInChildren.Any() ? includeElementsEvaluated : ApplyIncludeElementUpdates(includeElementsEvaluated, updatesInChildren);`
`202`	`202`	`}`
`203`	`203`
`204`		`- private static IImmutableList<IncludeElementExpression> ApplyIncludeElementUpdates(IImmutableList<IncludeElementExpression> includeElements,`
`205`		`- IDictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>> updatesInChildren)`
	`204`	`+ private static IImmutableSet<IncludeElementExpression> ApplyIncludeElementUpdates(IImmutableSet<IncludeElementExpression> includeElements,`
	`205`	`+ IDictionary<IncludeElementExpression, IImmutableSet<IncludeElementExpression>> updatesInChildren)`
`206`	`206`	`{`
`207`		`- ImmutableArray<IncludeElementExpression>.Builder newElementsBuilder = ImmutableArray.CreateBuilder<IncludeElementExpression>(includeElements.Count);`
	`207`	`+ ImmutableHashSet<IncludeElementExpression>.Builder newElementsBuilder = ImmutableHashSet.CreateBuilder<IncludeElementExpression>();`
`208`	`208`	`newElementsBuilder.AddRange(includeElements);`
`209`	`209`
`210`		`- foreach ((IncludeElementExpression existingElement, IImmutableList<IncludeElementExpression> updatedChildren) in updatesInChildren)`
	`210`	`+ foreach ((IncludeElementExpression existingElement, IImmutableSet<IncludeElementExpression> updatedChildren) in updatesInChildren)`
`211`	`211`	`{`
`212`		`- int existingIndex = newElementsBuilder.IndexOf(existingElement);`
`213`		`- newElementsBuilder[existingIndex] = new IncludeElementExpression(existingElement.Relationship, updatedChildren);`
	`212`	`+ newElementsBuilder.Remove(existingElement);`
	`213`	`+ newElementsBuilder.Add(new IncludeElementExpression(existingElement.Relationship, updatedChildren));`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`return newElementsBuilder.ToImmutable();`
`@@ -301,7 +301,7 @@ private IncludeExpression RewriteIncludeForSecondaryEndpoint(IncludeExpression r`
`301`	`301`	`? new IncludeElementExpression(secondaryRelationship, relativeInclude.Elements)`
`302`	`302`	`: new IncludeElementExpression(secondaryRelationship);`
`303`	`303`
`304`		`- return new IncludeExpression(ImmutableArray.Create(parentElement));`
	`304`	`+ return new IncludeExpression(ImmutableHashSet.Create(parentElement));`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`private FilterExpression CreateFilterByIds<TId>(IReadOnlyCollection<TId> ids, AttrAttribute idAttribute, FilterExpression existingFilter)`
`@@ -329,8 +329,8 @@ public QueryLayer ComposeForUpdate<TId>(TId id, ResourceContext primaryResource)`
`329`	`329`	`{`
`330`	`330`	`ArgumentGuard.NotNull(primaryResource, nameof(primaryResource));`
`331`	`331`
`332`		`- ImmutableArray<IncludeElementExpression> includeElements = _targetedFields.Relationships`
`333`		`- .Select(relationship => new IncludeElementExpression(relationship)).ToImmutableArray();`
	`332`	`+ IImmutableSet<IncludeElementExpression> includeElements = _targetedFields.Relationships`
	`333`	`+ .Select(relationship => new IncludeElementExpression(relationship)).ToImmutableHashSet();`
`334`	`334`
`335`	`335`	`AttrAttribute primaryIdAttribute = GetIdAttribute(primaryResource);`
`336`	`336`
`@@ -405,7 +405,7 @@ public QueryLayer ComposeForHasMany<TId>(HasManyAttribute hasManyRelationship, T`
`405`	`405`
`406`	`406`	`return new QueryLayer(leftResourceContext)`
`407`	`407`	`{`
`408`		`- Include = new IncludeExpression(ImmutableArray.Create(new IncludeElementExpression(hasManyRelationship))),`
	`408`	`+ Include = new IncludeExpression(ImmutableHashSet.Create(new IncludeElementExpression(hasManyRelationship))),`
`409`	`409`	`Filter = leftFilter,`
`410`	`410`	`Projection = new Dictionary<ResourceFieldAttribute, QueryLayer>`
`411`	`411`	`{`
`@@ -422,7 +422,7 @@ public QueryLayer ComposeForHasMany<TId>(HasManyAttribute hasManyRelationship, T`
`422`	`422`	`};`
`423`	`423`	`}`
`424`	`424`
`425`		`- protected virtual IImmutableList<IncludeElementExpression> GetIncludeElements(IImmutableList<IncludeElementExpression> includeElements,`
	`425`	`+ protected virtual IImmutableSet<IncludeElementExpression> GetIncludeElements(IImmutableSet<IncludeElementExpression> includeElements,`
`426`	`426`	`ResourceContext resourceContext)`
`427`	`427`	`{`
`428`	`428`	`ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public JsonApiResourceDefinition(IResourceGraph resourceGraph)`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`/// <inheritdoc />`
`55`		`- public virtual IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)`
	`55`	`+ public virtual IImmutableSet<IncludeElementExpression> OnApplyIncludes(IImmutableSet<IncludeElementExpression> existingIncludes)`
`56`	`56`	`{`
`57`	`57`	`return existingIncludes;`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public ResourceDefinitionAccessor(IResourceGraph resourceGraph, IServiceProvider`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`/// <inheritdoc />`
`32`		`- public IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<IncludeElementExpression> existingIncludes)`
	`32`	`+ public IImmutableSet<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableSet<IncludeElementExpression> existingIncludes)`
`33`	`33`	`{`
`34`	`34`	`ArgumentGuard.NotNull(resourceType, nameof(resourceType));`
`35`	`35`