Changed IncludeExpression.Elements type and IncludeElementExpression.Children type from IReadOnlyCollection to IImmutableList

Bart Koelman · Bart Koelman · commit 5d164f063638 · 2021-08-03T20:38:35.000+02:00
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));
 
-            IReadOnlyCollection<IncludeElementExpression> elements = ConvertChainsToElements(chains);
+            IImmutableList<IncludeElementExpression> elements = ConvertChainsToElements(chains);
             return elements.Any() ? new IncludeExpression(elements) : IncludeExpression.Empty;
         }
 
-        private static IReadOnlyCollection<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)
+        private static IImmutableList<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)
         {
             var rootNode = new MutableIncludeNode(null);
 
@@ -81,7 +81,7 @@ private static IReadOnlyCollection<IncludeElementExpression> ConvertChainsToElem
                 ConvertChainToElement(chain, rootNode);
             }
 
-            return rootNode.Children.Values.Select(child => child.ToExpression()).ToArray();
+            return rootNode.Children.Values.Select(child => child.ToExpression()).ToImmutableArray();
         }
 
         private static void ConvertChainToElement(ResourceFieldChainExpression chain, MutableIncludeNode rootNode)
@@ -161,7 +161,7 @@ public MutableIncludeNode(RelationshipAttribute relationship)
 
             public IncludeElementExpression ToExpression()
             {
-                IncludeElementExpression[] elementChildren = Children.Values.Select(child => child.ToExpression()).ToArray();
+                ImmutableArray<IncludeElementExpression> elementChildren = Children.Values.Select(child => child.ToExpression()).ToImmutableArray();
                 return new IncludeElementExpression(_relationship, elementChildren);
             }
         }
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IncludeElementExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/IncludeElementExpression.cs
@@ -1,5 +1,5 @@
 using System;
-using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Text;
 using JetBrains.Annotations;
@@ -14,14 +14,14 @@ namespace JsonApiDotNetCore.Queries.Expressions
     public class IncludeElementExpression : QueryExpression
     {
         public RelationshipAttribute Relationship { get; }
-        public IReadOnlyCollection<IncludeElementExpression> Children { get; }
+        public IImmutableList<IncludeElementExpression> Children { get; }
 
         public IncludeElementExpression(RelationshipAttribute relationship)
-            : this(relationship, Array.Empty<IncludeElementExpression>())
+            : this(relationship, ImmutableArray<IncludeElementExpression>.Empty)
         {
         }
 
-        public IncludeElementExpression(RelationshipAttribute relationship, IReadOnlyCollection<IncludeElementExpression> children)
+        public IncludeElementExpression(RelationshipAttribute relationship, IImmutableList<IncludeElementExpression> children)
         {
             ArgumentGuard.NotNull(relationship, nameof(relationship));
             ArgumentGuard.NotNull(children, nameof(children));
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/IncludeExpression.cs b/src/JsonApiDotNetCore/Queries/Expressions/IncludeExpression.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using JetBrains.Annotations;
 
@@ -15,9 +16,9 @@ public class IncludeExpression : QueryExpression
 
         public static readonly IncludeExpression Empty = new();
 
-        public IReadOnlyCollection<IncludeElementExpression> Elements { get; }
+        public IImmutableList<IncludeElementExpression> Elements { get; }
 
-        public IncludeExpression(IReadOnlyCollection<IncludeElementExpression> elements)
+        public IncludeExpression(IImmutableList<IncludeElementExpression> elements)
         {
             ArgumentGuard.NotNullNorEmpty(elements, nameof(elements));
 
@@ -26,7 +27,7 @@ public IncludeExpression(IReadOnlyCollection<IncludeElementExpression> elements)
 
         private IncludeExpression()
         {
-            Elements = Array.Empty<IncludeElementExpression>();
+            Elements = ImmutableArray<IncludeElementExpression>.Empty;
         }
 
         public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)
diff --git a/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs b/src/JsonApiDotNetCore/Queries/Expressions/QueryExpressionRewriter.cs
@@ -1,6 +1,4 @@
-using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Linq;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Configuration;
 
@@ -55,7 +53,7 @@ public override QueryExpression VisitLogical(LogicalExpression expression, TArgu
         {
             if (expression != null)
             {
-                var newTerms = VisitList(expression.Terms, argument);
+                IImmutableList<FilterExpression> newTerms = VisitList(expression.Terms, argument);
 
                 if (newTerms.Count == 1)
                 {
@@ -270,7 +268,7 @@ public override QueryExpression VisitInclude(IncludeExpression expression, TArgu
         {
             if (expression != null)
             {
-                IReadOnlyCollection<IncludeElementExpression> newElements = VisitSequence(expression.Elements, argument);
+                IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Elements, argument);
 
                 if (newElements.Count == 0)
                 {
@@ -288,7 +286,7 @@ public override QueryExpression VisitIncludeElement(IncludeElementExpression exp
         {
             if (expression != null)
             {
-                IReadOnlyCollection<IncludeElementExpression> newElements = VisitSequence(expression.Children, argument);
+                IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Children, argument);
 
                 var newExpression = new IncludeElementExpression(expression.Relationship, newElements);
                 return newExpression.Equals(expression) ? expression : newExpression;
@@ -302,22 +300,6 @@ public override QueryExpression VisitQueryableHandler(QueryableHandlerExpression
             return expression;
         }
 
-        protected virtual IReadOnlyCollection<TExpression> VisitSequence<TExpression>(IEnumerable<TExpression> elements, TArgument argument)
-            where TExpression : QueryExpression
-        {
-            var newElements = new List<TExpression>();
-
-            foreach (TExpression element in elements)
-            {
-                if (Visit(element, argument) is TExpression newElement)
-                {
-                    newElements.Add(newElement);
-                }
-            }
-
-            return newElements;
-        }
-
         protected virtual IImmutableList<TExpression> VisitList<TExpression>(IImmutableList<TExpression> elements, TArgument argument)
             where TExpression : QueryExpression
         {
diff --git a/src/JsonApiDotNetCore/Queries/Internal/Parsing/IncludeParser.cs b/src/JsonApiDotNetCore/Queries/Internal/Parsing/IncludeParser.cs
@@ -58,7 +58,7 @@ protected IncludeExpression ParseInclude(int? maximumDepth)
             return IncludeChainConverter.FromRelationshipChains(chains);
         }
 
-        private static void ValidateMaximumIncludeDepth(int? maximumDepth, IReadOnlyCollection<ResourceFieldChainExpression> chains)
+        private static void ValidateMaximumIncludeDepth(int? maximumDepth, IEnumerable<ResourceFieldChainExpression> chains)
         {
             if (maximumDepth != null)
             {
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryLayerComposer.cs
@@ -125,21 +125,21 @@ private IncludeExpression ComposeChildren(QueryLayer topLayer, ICollection<Expre
             // @formatter:keep_existing_linebreaks restore
             // @formatter:wrap_chained_method_calls restore
 
-            IReadOnlyCollection<IncludeElementExpression> includeElements =
+            IImmutableList<IncludeElementExpression> includeElements =
                 ProcessIncludeSet(include.Elements, topLayer, new List<RelationshipAttribute>(), constraints);
 
             return !ReferenceEquals(includeElements, include.Elements)
                 ? includeElements.Any() ? new IncludeExpression(includeElements) : IncludeExpression.Empty
                 : include;
         }
 
-        private IReadOnlyCollection<IncludeElementExpression> ProcessIncludeSet(IReadOnlyCollection<IncludeElementExpression> includeElements,
-            QueryLayer parentLayer, ICollection<RelationshipAttribute> parentRelationshipChain, ICollection<ExpressionInScope> constraints)
+        private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableList<IncludeElementExpression> includeElements, QueryLayer parentLayer,
+            ICollection<RelationshipAttribute> parentRelationshipChain, ICollection<ExpressionInScope> constraints)
         {
-            IReadOnlyCollection<IncludeElementExpression> includeElementsEvaluated =
-                GetIncludeElements(includeElements, parentLayer.ResourceContext) ?? Array.Empty<IncludeElementExpression>();
+            IImmutableList<IncludeElementExpression> includeElementsEvaluated =
+                GetIncludeElements(includeElements, parentLayer.ResourceContext) ?? ImmutableArray<IncludeElementExpression>.Empty;
 
-            var updatesInChildren = new Dictionary<IncludeElementExpression, IReadOnlyCollection<IncludeElementExpression>>();
+            var updatesInChildren = new Dictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>>();
 
             foreach (IncludeElementExpression includeElement in includeElementsEvaluated)
             {
@@ -181,7 +181,7 @@ private IReadOnlyCollection<IncludeElementExpression> ProcessIncludeSet(IReadOnl
 
                     if (includeElement.Children.Any())
                     {
-                        IReadOnlyCollection<IncludeElementExpression> updatedChildren =
+                        IImmutableList<IncludeElementExpression> updatedChildren =
                             ProcessIncludeSet(includeElement.Children, child, relationshipChain, constraints);
 
                         if (!ReferenceEquals(includeElement.Children, updatedChildren))
@@ -195,18 +195,19 @@ private IReadOnlyCollection<IncludeElementExpression> ProcessIncludeSet(IReadOnl
             return !updatesInChildren.Any() ? includeElementsEvaluated : ApplyIncludeElementUpdates(includeElementsEvaluated, updatesInChildren);
         }
 
-        private static IReadOnlyCollection<IncludeElementExpression> ApplyIncludeElementUpdates(IEnumerable<IncludeElementExpression> includeElements,
-            IDictionary<IncludeElementExpression, IReadOnlyCollection<IncludeElementExpression>> updatesInChildren)
+        private static IImmutableList<IncludeElementExpression> ApplyIncludeElementUpdates(IImmutableList<IncludeElementExpression> includeElements,
+            IDictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>> updatesInChildren)
         {
-            List<IncludeElementExpression> newIncludeElements = includeElements.ToList();
+            ImmutableArray<IncludeElementExpression>.Builder newElementsBuilder = ImmutableArray.CreateBuilder<IncludeElementExpression>(includeElements.Count);
+            newElementsBuilder.AddRange(includeElements);
 
-            foreach ((IncludeElementExpression existingElement, IReadOnlyCollection<IncludeElementExpression> updatedChildren) in updatesInChildren)
+            foreach ((IncludeElementExpression existingElement, IImmutableList<IncludeElementExpression> updatedChildren) in updatesInChildren)
             {
-                int existingIndex = newIncludeElements.IndexOf(existingElement);
-                newIncludeElements[existingIndex] = new IncludeElementExpression(existingElement.Relationship, updatedChildren);
+                int existingIndex = newElementsBuilder.IndexOf(existingElement);
+                newElementsBuilder[existingIndex] = new IncludeElementExpression(existingElement.Relationship, updatedChildren);
             }
 
-            return newIncludeElements;
+            return newElementsBuilder.ToImmutable();
         }
 
         /// <inheritdoc />
@@ -294,7 +295,7 @@ private IncludeExpression RewriteIncludeForSecondaryEndpoint(IncludeExpression r
                 ? new IncludeElementExpression(secondaryRelationship, relativeInclude.Elements)
                 : new IncludeElementExpression(secondaryRelationship);
 
-            return new IncludeExpression(parentElement.AsArray());
+            return new IncludeExpression(ImmutableArray.Create(parentElement));
         }
 
         private FilterExpression CreateFilterByIds<TId>(IReadOnlyCollection<TId> ids, AttrAttribute idAttribute, FilterExpression existingFilter)
@@ -310,7 +311,7 @@ private FilterExpression CreateFilterByIds<TId>(IReadOnlyCollection<TId> ids, At
             }
             else if (ids.Count > 1)
             {
-                IImmutableSet<LiteralConstantExpression> constants = ids.Select(id => new LiteralConstantExpression(id.ToString())).ToImmutableHashSet();
+                ImmutableHashSet<LiteralConstantExpression> constants = ids.Select(id => new LiteralConstantExpression(id.ToString())).ToImmutableHashSet();
                 filter = new AnyExpression(idChain, constants);
             }
 
@@ -322,8 +323,8 @@ public QueryLayer ComposeForUpdate<TId>(TId id, ResourceContext primaryResource)
         {
             ArgumentGuard.NotNull(primaryResource, nameof(primaryResource));
 
-            IncludeElementExpression[] includeElements = _targetedFields.Relationships
-                .Select(relationship => new IncludeElementExpression(relationship)).ToArray();
+            ImmutableArray<IncludeElementExpression> includeElements = _targetedFields.Relationships
+                .Select(relationship => new IncludeElementExpression(relationship)).ToImmutableArray();
 
             AttrAttribute primaryIdAttribute = GetIdAttribute(primaryResource);
 
@@ -398,7 +399,7 @@ public QueryLayer ComposeForHasMany<TId>(HasManyAttribute hasManyRelationship, T
 
             return new QueryLayer(leftResourceContext)
             {
-                Include = new IncludeExpression(new IncludeElementExpression(hasManyRelationship).AsArray()),
+                Include = new IncludeExpression(ImmutableArray.Create(new IncludeElementExpression(hasManyRelationship))),
                 Filter = leftFilter,
                 Projection = new Dictionary<ResourceFieldAttribute, QueryLayer>
                 {
@@ -421,7 +422,7 @@ public IResourceDefinitionAccessor GetResourceDefinitionAccessor()
             return _resourceDefinitionAccessor;
         }
 
-        protected virtual IReadOnlyCollection<IncludeElementExpression> GetIncludeElements(IReadOnlyCollection<IncludeElementExpression> includeElements,
+        protected virtual IImmutableList<IncludeElementExpression> GetIncludeElements(IImmutableList<IncludeElementExpression> includeElements,
             ResourceContext resourceContext)
         {
             ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
@@ -434,8 +435,8 @@ protected virtual FilterExpression GetFilter(IReadOnlyCollection<QueryExpression
             ArgumentGuard.NotNull(expressionsInScope, nameof(expressionsInScope));
             ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));
 
-            IImmutableList<FilterExpression> filters = expressionsInScope.OfType<FilterExpression>().ToImmutableArray();
-            FilterExpression filter = filters.Count > 1 ? new LogicalExpression(LogicalOperator.And, filters) : filters.FirstOrDefault();
+            ImmutableArray<FilterExpression> filters = expressionsInScope.OfType<FilterExpression>().ToImmutableArray();
+            FilterExpression filter = filters.Length > 1 ? new LogicalExpression(LogicalOperator.And, filters) : filters.FirstOrDefault();
 
             return _resourceDefinitionAccessor.OnApplyFilter(resourceContext.ResourceType, filter);
         }
diff --git a/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryClauseBuilder.cs b/src/JsonApiDotNetCore/Queries/Internal/QueryableBuilding/QueryClauseBuilder.cs
@@ -65,7 +65,7 @@ public override Expression VisitResourceFieldChain(ResourceFieldChainExpression
             return CreatePropertyExpressionFromComponents(LambdaScope.Accessor, components);
         }
 
-        private static MemberExpression CreatePropertyExpressionFromComponents(Expression source, IReadOnlyCollection<string> components)
+        private static MemberExpression CreatePropertyExpressionFromComponents(Expression source, IEnumerable<string> components)
         {
             MemberExpression property = null;
 
diff --git a/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs b/src/JsonApiDotNetCore/Resources/IResourceDefinition.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -44,7 +45,7 @@ public interface IResourceDefinition<TResource, TId>
         /// <returns>
         /// The new set of includes. Return an empty collection to remove all inclusions (never return <c>null</c>).
         /// </returns>
-        IReadOnlyCollection<IncludeElementExpression> OnApplyIncludes(IReadOnlyCollection<IncludeElementExpression> existingIncludes);
+        IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<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
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,7 +18,7 @@ public interface IResourceDefinitionAccessor
         /// <summary>
         /// Invokes <see cref="IResourceDefinition{TResource,TId}.OnApplyIncludes" /> for the specified resource type.
         /// </summary>
-        IReadOnlyCollection<IncludeElementExpression> OnApplyIncludes(Type resourceType, IReadOnlyCollection<IncludeElementExpression> existingIncludes);
+        IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<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 IReadOnlyCollection<IncludeElementExpression> OnApplyIncludes(IReadOnlyCollection<IncludeElementExpression> existingIncludes)
+        public virtual IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)
         {
             return existingIncludes;
         }
diff --git a/src/JsonApiDotNetCore/Resources/ResourceDefinitionAccessor.cs b/src/JsonApiDotNetCore/Resources/ResourceDefinitionAccessor.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
@@ -28,7 +29,7 @@ public ResourceDefinitionAccessor(IResourceContextProvider resourceContextProvid
         }
 
         /// <inheritdoc />
-        public IReadOnlyCollection<IncludeElementExpression> OnApplyIncludes(Type resourceType, IReadOnlyCollection<IncludeElementExpression> existingIncludes)
+        public IImmutableList<IncludeElementExpression> OnApplyIncludes(Type resourceType, IImmutableList<IncludeElementExpression> existingIncludes)
         {
             ArgumentGuard.NotNull(resourceType, nameof(resourceType));
 
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/MoonDefinition.cs
diff --git a/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/PlanetDefinition.cs b/test/JsonApiDotNetCoreExampleTests/IntegrationTests/ResourceDefinitions/Reading/PlanetDefinition.cs
diff --git a/test/UnitTests/Extensions/ServiceCollectionExtensionsTests.cs b/test/UnitTests/Extensions/ServiceCollectionExtensionsTests.cs
diff --git a/test/UnitTests/NeverResourceDefinitionAccessor.cs b/test/UnitTests/NeverResourceDefinitionAccessor.cs

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`		`- IReadOnlyCollection<IncludeElementExpression> elements = ConvertChainsToElements(chains);`
	`71`	`+ IImmutableList<IncludeElementExpression> elements = ConvertChainsToElements(chains);`
`72`	`72`	`return elements.Any() ? new IncludeExpression(elements) : IncludeExpression.Empty;`
`73`	`73`	`}`
`74`	`74`
`75`		`- private static IReadOnlyCollection<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)`
	`75`	`+ private static IImmutableList<IncludeElementExpression> ConvertChainsToElements(IEnumerable<ResourceFieldChainExpression> chains)`
`76`	`76`	`{`
`77`	`77`	`var rootNode = new MutableIncludeNode(null);`
`78`	`78`
`@@ -81,7 +81,7 @@ private static IReadOnlyCollection<IncludeElementExpression> ConvertChainsToElem`
`81`	`81`	`ConvertChainToElement(chain, rootNode);`
`82`	`82`	`}`
`83`	`83`
`84`		`- return rootNode.Children.Values.Select(child => child.ToExpression()).ToArray();`
	`84`	`+ return rootNode.Children.Values.Select(child => child.ToExpression()).ToImmutableArray();`
`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`		`- IncludeElementExpression[] elementChildren = Children.Values.Select(child => child.ToExpression()).ToArray();`
	`164`	`+ ImmutableArray<IncludeElementExpression> elementChildren = Children.Values.Select(child => child.ToExpression()).ToImmutableArray();`
`165`	`165`	`return new IncludeElementExpression(_relationship, elementChildren);`
`166`	`166`	`}`
`167`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections.Generic;`
	`2`	`+using System.Collections.Immutable;`
`3`	`3`	`using System.Linq;`
`4`	`4`	`using System.Text;`
`5`	`5`	`using JetBrains.Annotations;`
`@@ -14,14 +14,14 @@ namespace JsonApiDotNetCore.Queries.Expressions`
`14`	`14`	`public class IncludeElementExpression : QueryExpression`
`15`	`15`	`{`
`16`	`16`	`public RelationshipAttribute Relationship { get; }`
`17`		`- public IReadOnlyCollection<IncludeElementExpression> Children { get; }`
	`17`	`+ public IImmutableList<IncludeElementExpression> Children { get; }`
`18`	`18`
`19`	`19`	`public IncludeElementExpression(RelationshipAttribute relationship)`
`20`		`- : this(relationship, Array.Empty<IncludeElementExpression>())`
	`20`	`+ : this(relationship, ImmutableArray<IncludeElementExpression>.Empty)`
`21`	`21`	`{`
`22`	`22`	`}`
`23`	`23`
`24`		`- public IncludeElementExpression(RelationshipAttribute relationship, IReadOnlyCollection<IncludeElementExpression> children)`
	`24`	`+ public IncludeElementExpression(RelationshipAttribute relationship, IImmutableList<IncludeElementExpression> children)`
`25`	`25`	`{`
`26`	`26`	`ArgumentGuard.NotNull(relationship, nameof(relationship));`
`27`	`27`	`ArgumentGuard.NotNull(children, nameof(children));`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Collections.Immutable;`
`3`	`4`	`using System.Linq;`
`4`	`5`	`using JetBrains.Annotations;`
`5`	`6`
`@@ -15,9 +16,9 @@ public class IncludeExpression : QueryExpression`
`15`	`16`
`16`	`17`	`public static readonly IncludeExpression Empty = new();`
`17`	`18`
`18`		`- public IReadOnlyCollection<IncludeElementExpression> Elements { get; }`
	`19`	`+ public IImmutableList<IncludeElementExpression> Elements { get; }`
`19`	`20`
`20`		`- public IncludeExpression(IReadOnlyCollection<IncludeElementExpression> elements)`
	`21`	`+ public IncludeExpression(IImmutableList<IncludeElementExpression> elements)`
`21`	`22`	`{`
`22`	`23`	`ArgumentGuard.NotNullNorEmpty(elements, nameof(elements));`
`23`	`24`
`@@ -26,7 +27,7 @@ public IncludeExpression(IReadOnlyCollection<IncludeElementExpression> elements)`
`26`	`27`
`27`	`28`	`private IncludeExpression()`
`28`	`29`	`{`
`29`		`- Elements = Array.Empty<IncludeElementExpression>();`
	`30`	`+ Elements = ImmutableArray<IncludeElementExpression>.Empty;`
`30`	`31`	`}`
`31`	`32`
`32`	`33`	`public override TResult Accept<TArgument, TResult>(QueryExpressionVisitor<TArgument, TResult> visitor, TArgument argument)`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,4 @@`
`1`		`-using System.Collections.Generic;`
`2`	`1`	`using System.Collections.Immutable;`
`3`		`-using System.Linq;`
`4`	`2`	`using JetBrains.Annotations;`
`5`	`3`	`using JsonApiDotNetCore.Configuration;`
`6`	`4`
`@@ -55,7 +53,7 @@ public override QueryExpression VisitLogical(LogicalExpression expression, TArgu`
`55`	`53`	`{`
`56`	`54`	`if (expression != null)`
`57`	`55`	`{`
`58`		`- var newTerms = VisitList(expression.Terms, argument);`
	`56`	`+ IImmutableList<FilterExpression> newTerms = VisitList(expression.Terms, argument);`
`59`	`57`
`60`	`58`	`if (newTerms.Count == 1)`
`61`	`59`	`{`
`@@ -270,7 +268,7 @@ public override QueryExpression VisitInclude(IncludeExpression expression, TArgu`
`270`	`268`	`{`
`271`	`269`	`if (expression != null)`
`272`	`270`	`{`
`273`		`- IReadOnlyCollection<IncludeElementExpression> newElements = VisitSequence(expression.Elements, argument);`
	`271`	`+ IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Elements, argument);`
`274`	`272`
`275`	`273`	`if (newElements.Count == 0)`
`276`	`274`	`{`
`@@ -288,7 +286,7 @@ public override QueryExpression VisitIncludeElement(IncludeElementExpression exp`
`288`	`286`	`{`
`289`	`287`	`if (expression != null)`
`290`	`288`	`{`
`291`		`- IReadOnlyCollection<IncludeElementExpression> newElements = VisitSequence(expression.Children, argument);`
	`289`	`+ IImmutableList<IncludeElementExpression> newElements = VisitList(expression.Children, argument);`
`292`	`290`
`293`	`291`	`var newExpression = new IncludeElementExpression(expression.Relationship, newElements);`
`294`	`292`	`return newExpression.Equals(expression) ? expression : newExpression;`
`@@ -302,22 +300,6 @@ public override QueryExpression VisitQueryableHandler(QueryableHandlerExpression`
`302`	`300`	`return expression;`
`303`	`301`	`}`
`304`	`302`
`305`		`- protected virtual IReadOnlyCollection<TExpression> VisitSequence<TExpression>(IEnumerable<TExpression> elements, TArgument argument)`
`306`		`- where TExpression : QueryExpression`
`307`		`- {`
`308`		`- var newElements = new List<TExpression>();`
`309`		`-`
`310`		`- foreach (TExpression element in elements)`
`311`		`- {`
`312`		`- if (Visit(element, argument) is TExpression newElement)`
`313`		`- {`
`314`		`- newElements.Add(newElement);`
`315`		`- }`
`316`		`- }`
`317`		`-`
`318`		`- return newElements;`
`319`		`- }`
`320`		`-`
`321`	`303`	`protected virtual IImmutableList<TExpression> VisitList<TExpression>(IImmutableList<TExpression> elements, TArgument argument)`
`322`	`304`	`where TExpression : QueryExpression`
`323`	`305`	`{`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ protected IncludeExpression ParseInclude(int? maximumDepth)`
`58`	`58`	`return IncludeChainConverter.FromRelationshipChains(chains);`
`59`	`59`	`}`
`60`	`60`
`61`		`- private static void ValidateMaximumIncludeDepth(int? maximumDepth, IReadOnlyCollection<ResourceFieldChainExpression> chains)`
	`61`	`+ private static void ValidateMaximumIncludeDepth(int? maximumDepth, IEnumerable<ResourceFieldChainExpression> chains)`
`62`	`62`	`{`
`63`	`63`	`if (maximumDepth != null)`
`64`	`64`	`{`
Original file line number	Diff line number	Diff line change
`@@ -125,21 +125,21 @@ private IncludeExpression ComposeChildren(QueryLayer topLayer, ICollection<Expre`
`125`	`125`	`// @formatter:keep_existing_linebreaks restore`
`126`	`126`	`// @formatter:wrap_chained_method_calls restore`
`127`	`127`
`128`		`- IReadOnlyCollection<IncludeElementExpression> includeElements =`
	`128`	`+ IImmutableList<IncludeElementExpression> includeElements =`
`129`	`129`	`ProcessIncludeSet(include.Elements, topLayer, new List<RelationshipAttribute>(), constraints);`
`130`	`130`
`131`	`131`	`return !ReferenceEquals(includeElements, include.Elements)`
`132`	`132`	`? includeElements.Any() ? new IncludeExpression(includeElements) : IncludeExpression.Empty`
`133`	`133`	`: include;`
`134`	`134`	`}`
`135`	`135`
`136`		`- private IReadOnlyCollection<IncludeElementExpression> ProcessIncludeSet(IReadOnlyCollection<IncludeElementExpression> includeElements,`
`137`		`- QueryLayer parentLayer, ICollection<RelationshipAttribute> parentRelationshipChain, ICollection<ExpressionInScope> constraints)`
	`136`	`+ private IImmutableList<IncludeElementExpression> ProcessIncludeSet(IImmutableList<IncludeElementExpression> includeElements, QueryLayer parentLayer,`
	`137`	`+ ICollection<RelationshipAttribute> parentRelationshipChain, ICollection<ExpressionInScope> constraints)`
`138`	`138`	`{`
`139`		`- IReadOnlyCollection<IncludeElementExpression> includeElementsEvaluated =`
`140`		`- GetIncludeElements(includeElements, parentLayer.ResourceContext) ?? Array.Empty<IncludeElementExpression>();`
	`139`	`+ IImmutableList<IncludeElementExpression> includeElementsEvaluated =`
	`140`	`+ GetIncludeElements(includeElements, parentLayer.ResourceContext) ?? ImmutableArray<IncludeElementExpression>.Empty;`
`141`	`141`
`142`		`- var updatesInChildren = new Dictionary<IncludeElementExpression, IReadOnlyCollection<IncludeElementExpression>>();`
	`142`	`+ var updatesInChildren = new Dictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>>();`
`143`	`143`
`144`	`144`	`foreach (IncludeElementExpression includeElement in includeElementsEvaluated)`
`145`	`145`	`{`
`@@ -181,7 +181,7 @@ private IReadOnlyCollection<IncludeElementExpression> ProcessIncludeSet(IReadOnl`
`181`	`181`
`182`	`182`	`if (includeElement.Children.Any())`
`183`	`183`	`{`
`184`		`- IReadOnlyCollection<IncludeElementExpression> updatedChildren =`
	`184`	`+ IImmutableList<IncludeElementExpression> updatedChildren =`
`185`	`185`	`ProcessIncludeSet(includeElement.Children, child, relationshipChain, constraints);`
`186`	`186`
`187`	`187`	`if (!ReferenceEquals(includeElement.Children, updatedChildren))`
`@@ -195,18 +195,19 @@ private IReadOnlyCollection<IncludeElementExpression> ProcessIncludeSet(IReadOnl`
`195`	`195`	`return !updatesInChildren.Any() ? includeElementsEvaluated : ApplyIncludeElementUpdates(includeElementsEvaluated, updatesInChildren);`
`196`	`196`	`}`
`197`	`197`
`198`		`- private static IReadOnlyCollection<IncludeElementExpression> ApplyIncludeElementUpdates(IEnumerable<IncludeElementExpression> includeElements,`
`199`		`- IDictionary<IncludeElementExpression, IReadOnlyCollection<IncludeElementExpression>> updatesInChildren)`
	`198`	`+ private static IImmutableList<IncludeElementExpression> ApplyIncludeElementUpdates(IImmutableList<IncludeElementExpression> includeElements,`
	`199`	`+ IDictionary<IncludeElementExpression, IImmutableList<IncludeElementExpression>> updatesInChildren)`
`200`	`200`	`{`
`201`		`- List<IncludeElementExpression> newIncludeElements = includeElements.ToList();`
	`201`	`+ ImmutableArray<IncludeElementExpression>.Builder newElementsBuilder = ImmutableArray.CreateBuilder<IncludeElementExpression>(includeElements.Count);`
	`202`	`+ newElementsBuilder.AddRange(includeElements);`
`202`	`203`
`203`		`- foreach ((IncludeElementExpression existingElement, IReadOnlyCollection<IncludeElementExpression> updatedChildren) in updatesInChildren)`
	`204`	`+ foreach ((IncludeElementExpression existingElement, IImmutableList<IncludeElementExpression> updatedChildren) in updatesInChildren)`
`204`	`205`	`{`
`205`		`- int existingIndex = newIncludeElements.IndexOf(existingElement);`
`206`		`- newIncludeElements[existingIndex] = new IncludeElementExpression(existingElement.Relationship, updatedChildren);`
	`206`	`+ int existingIndex = newElementsBuilder.IndexOf(existingElement);`
	`207`	`+ newElementsBuilder[existingIndex] = new IncludeElementExpression(existingElement.Relationship, updatedChildren);`
`207`	`208`	`}`
`208`	`209`
`209`		`- return newIncludeElements;`
	`210`	`+ return newElementsBuilder.ToImmutable();`
`210`	`211`	`}`
`211`	`212`
`212`	`213`	`/// <inheritdoc />`
`@@ -294,7 +295,7 @@ private IncludeExpression RewriteIncludeForSecondaryEndpoint(IncludeExpression r`
`294`	`295`	`? new IncludeElementExpression(secondaryRelationship, relativeInclude.Elements)`
`295`	`296`	`: new IncludeElementExpression(secondaryRelationship);`
`296`	`297`
`297`		`- return new IncludeExpression(parentElement.AsArray());`
	`298`	`+ return new IncludeExpression(ImmutableArray.Create(parentElement));`
`298`	`299`	`}`
`299`	`300`
`300`	`301`	`private FilterExpression CreateFilterByIds<TId>(IReadOnlyCollection<TId> ids, AttrAttribute idAttribute, FilterExpression existingFilter)`
`@@ -310,7 +311,7 @@ private FilterExpression CreateFilterByIds<TId>(IReadOnlyCollection<TId> ids, At`
`310`	`311`	`}`
`311`	`312`	`else if (ids.Count > 1)`
`312`	`313`	`{`
`313`		`- IImmutableSet<LiteralConstantExpression> constants = ids.Select(id => new LiteralConstantExpression(id.ToString())).ToImmutableHashSet();`
	`314`	`+ ImmutableHashSet<LiteralConstantExpression> constants = ids.Select(id => new LiteralConstantExpression(id.ToString())).ToImmutableHashSet();`
`314`	`315`	`filter = new AnyExpression(idChain, constants);`
`315`	`316`	`}`
`316`	`317`
`@@ -322,8 +323,8 @@ public QueryLayer ComposeForUpdate<TId>(TId id, ResourceContext primaryResource)`
`322`	`323`	`{`
`323`	`324`	`ArgumentGuard.NotNull(primaryResource, nameof(primaryResource));`
`324`	`325`
`325`		`- IncludeElementExpression[] includeElements = _targetedFields.Relationships`
`326`		`- .Select(relationship => new IncludeElementExpression(relationship)).ToArray();`
	`326`	`+ ImmutableArray<IncludeElementExpression> includeElements = _targetedFields.Relationships`
	`327`	`+ .Select(relationship => new IncludeElementExpression(relationship)).ToImmutableArray();`
`327`	`328`
`328`	`329`	`AttrAttribute primaryIdAttribute = GetIdAttribute(primaryResource);`
`329`	`330`
`@@ -398,7 +399,7 @@ public QueryLayer ComposeForHasMany<TId>(HasManyAttribute hasManyRelationship, T`
`398`	`399`
`399`	`400`	`return new QueryLayer(leftResourceContext)`
`400`	`401`	`{`
`401`		`- Include = new IncludeExpression(new IncludeElementExpression(hasManyRelationship).AsArray()),`
	`402`	`+ Include = new IncludeExpression(ImmutableArray.Create(new IncludeElementExpression(hasManyRelationship))),`
`402`	`403`	`Filter = leftFilter,`
`403`	`404`	`Projection = new Dictionary<ResourceFieldAttribute, QueryLayer>`
`404`	`405`	`{`
`@@ -421,7 +422,7 @@ public IResourceDefinitionAccessor GetResourceDefinitionAccessor()`
`421`	`422`	`return _resourceDefinitionAccessor;`
`422`	`423`	`}`
`423`	`424`
`424`		`- protected virtual IReadOnlyCollection<IncludeElementExpression> GetIncludeElements(IReadOnlyCollection<IncludeElementExpression> includeElements,`
	`425`	`+ protected virtual IImmutableList<IncludeElementExpression> GetIncludeElements(IImmutableList<IncludeElementExpression> includeElements,`
`425`	`426`	`ResourceContext resourceContext)`
`426`	`427`	`{`
`427`	`428`	`ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));`
`@@ -434,8 +435,8 @@ protected virtual FilterExpression GetFilter(IReadOnlyCollection<QueryExpression`
`434`	`435`	`ArgumentGuard.NotNull(expressionsInScope, nameof(expressionsInScope));`
`435`	`436`	`ArgumentGuard.NotNull(resourceContext, nameof(resourceContext));`
`436`	`437`
`437`		`- IImmutableList<FilterExpression> filters = expressionsInScope.OfType<FilterExpression>().ToImmutableArray();`
`438`		`- FilterExpression filter = filters.Count > 1 ? new LogicalExpression(LogicalOperator.And, filters) : filters.FirstOrDefault();`
	`438`	`+ ImmutableArray<FilterExpression> filters = expressionsInScope.OfType<FilterExpression>().ToImmutableArray();`
	`439`	`+ FilterExpression filter = filters.Length > 1 ? new LogicalExpression(LogicalOperator.And, filters) : filters.FirstOrDefault();`
`439`	`440`
`440`	`441`	`return _resourceDefinitionAccessor.OnApplyFilter(resourceContext.ResourceType, filter);`
`441`	`442`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public override Expression VisitResourceFieldChain(ResourceFieldChainExpression`
`65`	`65`	`return CreatePropertyExpressionFromComponents(LambdaScope.Accessor, components);`
`66`	`66`	`}`
`67`	`67`
`68`		`- private static MemberExpression CreatePropertyExpressionFromComponents(Expression source, IReadOnlyCollection<string> components)`
	`68`	`+ private static MemberExpression CreatePropertyExpressionFromComponents(Expression source, IEnumerable<string> components)`
`69`	`69`	`{`
`70`	`70`	`MemberExpression property = null;`
`71`	`71`
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 IReadOnlyCollection<IncludeElementExpression> OnApplyIncludes(IReadOnlyCollection<IncludeElementExpression> existingIncludes)`
	`55`	`+ public virtual IImmutableList<IncludeElementExpression> OnApplyIncludes(IImmutableList<IncludeElementExpression> existingIncludes)`
`56`	`56`	`{`
`57`	`57`	`return existingIncludes;`
`58`	`58`	`}`