AV1562: Do not use ref/out parameters

Bart Koelman · Bart Koelman · commit 8d887e2dbb6d · 2021-03-08T17:06:17.000+01:00
diff --git a/src/JsonApiDotNetCore/Hooks/Internal/Execution/HookExecutorHelper.cs b/src/JsonApiDotNetCore/Hooks/Internal/Execution/HookExecutorHelper.cs
@@ -209,7 +209,10 @@ public Dictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(Dic
 
             foreach (KeyValuePair<RelationshipAttribute, IEnumerable> kvp in leftResourcesByRelation)
             {
-                if (IsHasManyThrough(kvp, out IEnumerable lefts, out RelationshipAttribute relationship))
+                RelationshipAttribute relationship = kvp.Key;
+                IEnumerable lefts = kvp.Value;
+
+                if (relationship is HasManyThroughAttribute)
                 {
                     continue;
                 }
@@ -270,12 +273,5 @@ private static void AddToList(IList list, IEnumerable itemsToAdd)
                 list.Add(item);
             }
         }
-
-        private bool IsHasManyThrough(KeyValuePair<RelationshipAttribute, IEnumerable> kvp, out IEnumerable resources, out RelationshipAttribute attr)
-        {
-            attr = kvp.Key;
-            resources = kvp.Value;
-            return kvp.Key is HasManyThroughAttribute;
-        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Hooks/Internal/ResourceHookExecutor.cs b/src/JsonApiDotNetCore/Hooks/Internal/ResourceHookExecutor.cs
@@ -67,60 +67,69 @@ public void BeforeRead<TResource>(ResourcePipeline pipeline, string stringId = n
         public IEnumerable<TResource> BeforeUpdate<TResource>(IEnumerable<TResource> resources, ResourcePipeline pipeline)
             where TResource : class, IIdentifiable
         {
-            if (GetHook(ResourceHook.BeforeUpdate, resources, out IResourceHookContainer<TResource> container, out RootNode<TResource> node))
+            GetHookResult<TResource> result = GetHook(ResourceHook.BeforeUpdate, resources);
+
+            if (result.Succeeded)
             {
-                RelationshipAttribute[] relationships = node.RelationshipsToNextLayer.Select(proxy => proxy.Attribute).ToArray();
-                IEnumerable dbValues = LoadDbValues(typeof(TResource), (IEnumerable<TResource>)node.UniqueResources, ResourceHook.BeforeUpdate, relationships);
-                var diff = new DiffableResourceHashSet<TResource>(node.UniqueResources, dbValues, node.LeftsToNextLayer(), _targetedFields);
-                IEnumerable<TResource> updated = container.BeforeUpdate(diff, pipeline);
-                node.UpdateUnique(updated);
-                node.Reassign(resources);
+                RelationshipAttribute[] relationships = result.Node.RelationshipsToNextLayer.Select(proxy => proxy.Attribute).ToArray();
+
+                IEnumerable dbValues = LoadDbValues(typeof(TResource), (IEnumerable<TResource>)result.Node.UniqueResources, ResourceHook.BeforeUpdate,
+                    relationships);
+
+                var diff = new DiffableResourceHashSet<TResource>(result.Node.UniqueResources, dbValues, result.Node.LeftsToNextLayer(), _targetedFields);
+                IEnumerable<TResource> updated = result.Container.BeforeUpdate(diff, pipeline);
+                result.Node.UpdateUnique(updated);
+                result.Node.Reassign(resources);
             }
 
-            FireNestedBeforeUpdateHooks(pipeline, _traversalHelper.CreateNextLayer(node));
+            FireNestedBeforeUpdateHooks(pipeline, _traversalHelper.CreateNextLayer(result.Node));
             return resources;
         }
 
         /// <inheritdoc />
         public IEnumerable<TResource> BeforeCreate<TResource>(IEnumerable<TResource> resources, ResourcePipeline pipeline)
             where TResource : class, IIdentifiable
         {
-            if (GetHook(ResourceHook.BeforeCreate, resources, out IResourceHookContainer<TResource> container, out RootNode<TResource> node))
+            GetHookResult<TResource> result = GetHook(ResourceHook.BeforeCreate, resources);
+
+            if (result.Succeeded)
             {
-                var affected = new ResourceHashSet<TResource>((HashSet<TResource>)node.UniqueResources, node.LeftsToNextLayer());
-                IEnumerable<TResource> updated = container.BeforeCreate(affected, pipeline);
-                node.UpdateUnique(updated);
-                node.Reassign(resources);
+                var affected = new ResourceHashSet<TResource>((HashSet<TResource>)result.Node.UniqueResources, result.Node.LeftsToNextLayer());
+                IEnumerable<TResource> updated = result.Container.BeforeCreate(affected, pipeline);
+                result.Node.UpdateUnique(updated);
+                result.Node.Reassign(resources);
             }
 
-            FireNestedBeforeUpdateHooks(pipeline, _traversalHelper.CreateNextLayer(node));
+            FireNestedBeforeUpdateHooks(pipeline, _traversalHelper.CreateNextLayer(result.Node));
             return resources;
         }
 
         /// <inheritdoc />
         public IEnumerable<TResource> BeforeDelete<TResource>(IEnumerable<TResource> resources, ResourcePipeline pipeline)
             where TResource : class, IIdentifiable
         {
-            if (GetHook(ResourceHook.BeforeDelete, resources, out IResourceHookContainer<TResource> container, out RootNode<TResource> node))
+            GetHookResult<TResource> result = GetHook(ResourceHook.BeforeDelete, resources);
+
+            if (result.Succeeded)
             {
-                RelationshipAttribute[] relationships = node.RelationshipsToNextLayer.Select(proxy => proxy.Attribute).ToArray();
+                RelationshipAttribute[] relationships = result.Node.RelationshipsToNextLayer.Select(proxy => proxy.Attribute).ToArray();
 
                 IEnumerable targetResources =
-                    LoadDbValues(typeof(TResource), (IEnumerable<TResource>)node.UniqueResources, ResourceHook.BeforeDelete, relationships) ??
-                    node.UniqueResources;
+                    LoadDbValues(typeof(TResource), (IEnumerable<TResource>)result.Node.UniqueResources, ResourceHook.BeforeDelete, relationships) ??
+                    result.Node.UniqueResources;
 
-                var affected = new ResourceHashSet<TResource>(targetResources, node.LeftsToNextLayer());
+                var affected = new ResourceHashSet<TResource>(targetResources, result.Node.LeftsToNextLayer());
 
-                IEnumerable<TResource> updated = container.BeforeDelete(affected, pipeline);
-                node.UpdateUnique(updated);
-                node.Reassign(resources);
+                IEnumerable<TResource> updated = result.Container.BeforeDelete(affected, pipeline);
+                result.Node.UpdateUnique(updated);
+                result.Node.Reassign(resources);
             }
 
             // If we're deleting an article, we're implicitly affected any owners related to it.
             // Here we're loading all relations onto the to-be-deleted article
             // if for that relation the BeforeImplicitUpdateHook is implemented,
             // and this hook is then executed
-            foreach (KeyValuePair<Type, Dictionary<RelationshipAttribute, IEnumerable>> entry in node.LeftsToNextLayerByRelationships())
+            foreach (KeyValuePair<Type, Dictionary<RelationshipAttribute, IEnumerable>> entry in result.Node.LeftsToNextLayerByRelationships())
             {
                 Type rightType = entry.Key;
                 Dictionary<RelationshipAttribute, IEnumerable> implicitTargets = entry.Value;
@@ -134,15 +143,17 @@ public IEnumerable<TResource> BeforeDelete<TResource>(IEnumerable<TResource> res
         public IEnumerable<TResource> OnReturn<TResource>(IEnumerable<TResource> resources, ResourcePipeline pipeline)
             where TResource : class, IIdentifiable
         {
-            if (GetHook(ResourceHook.OnReturn, resources, out IResourceHookContainer<TResource> container, out RootNode<TResource> node))
+            GetHookResult<TResource> result = GetHook(ResourceHook.OnReturn, resources);
+
+            if (result.Succeeded)
             {
-                IEnumerable<TResource> updated = container.OnReturn((HashSet<TResource>)node.UniqueResources, pipeline);
+                IEnumerable<TResource> updated = result.Container.OnReturn((HashSet<TResource>)result.Node.UniqueResources, pipeline);
                 ValidateHookResponse(updated);
-                node.UpdateUnique(updated);
-                node.Reassign(resources);
+                result.Node.UpdateUnique(updated);
+                result.Node.Reassign(resources);
             }
 
-            Traverse(_traversalHelper.CreateNextLayer(node), ResourceHook.OnReturn, (nextContainer, nextNode) =>
+            Traverse(_traversalHelper.CreateNextLayer(result.Node), ResourceHook.OnReturn, (nextContainer, nextNode) =>
             {
                 IEnumerable filteredUniqueSet = CallHook(nextContainer, ResourceHook.OnReturn, ArrayFactory.Create<object>(nextNode.UniqueResources, pipeline));
                 nextNode.UpdateUnique(filteredUniqueSet);
@@ -156,12 +167,14 @@ public IEnumerable<TResource> OnReturn<TResource>(IEnumerable<TResource> resourc
         public void AfterRead<TResource>(IEnumerable<TResource> resources, ResourcePipeline pipeline)
             where TResource : class, IIdentifiable
         {
-            if (GetHook(ResourceHook.AfterRead, resources, out IResourceHookContainer<TResource> container, out RootNode<TResource> node))
+            GetHookResult<TResource> result = GetHook(ResourceHook.AfterRead, resources);
+
+            if (result.Succeeded)
             {
-                container.AfterRead((HashSet<TResource>)node.UniqueResources, pipeline);
+                result.Container.AfterRead((HashSet<TResource>)result.Node.UniqueResources, pipeline);
             }
 
-            Traverse(_traversalHelper.CreateNextLayer(node), ResourceHook.AfterRead, (nextContainer, nextNode) =>
+            Traverse(_traversalHelper.CreateNextLayer(result.Node), ResourceHook.AfterRead, (nextContainer, nextNode) =>
             {
                 CallHook(nextContainer, ResourceHook.AfterRead, ArrayFactory.Create<object>(nextNode.UniqueResources, pipeline, true));
             });
@@ -171,35 +184,41 @@ public void AfterRead<TResource>(IEnumerable<TResource> resources, ResourcePipel
         public void AfterCreate<TResource>(IEnumerable<TResource> resources, ResourcePipeline pipeline)
             where TResource : class, IIdentifiable
         {
-            if (GetHook(ResourceHook.AfterCreate, resources, out IResourceHookContainer<TResource> container, out RootNode<TResource> node))
+            GetHookResult<TResource> result = GetHook(ResourceHook.AfterCreate, resources);
+
+            if (result.Succeeded)
             {
-                container.AfterCreate((HashSet<TResource>)node.UniqueResources, pipeline);
+                result.Container.AfterCreate((HashSet<TResource>)result.Node.UniqueResources, pipeline);
             }
 
-            Traverse(_traversalHelper.CreateNextLayer(node), ResourceHook.AfterUpdateRelationship,
+            Traverse(_traversalHelper.CreateNextLayer(result.Node), ResourceHook.AfterUpdateRelationship,
                 (nextContainer, nextNode) => FireAfterUpdateRelationship(nextContainer, nextNode, pipeline));
         }
 
         /// <inheritdoc />
         public void AfterUpdate<TResource>(IEnumerable<TResource> resources, ResourcePipeline pipeline)
             where TResource : class, IIdentifiable
         {
-            if (GetHook(ResourceHook.AfterUpdate, resources, out IResourceHookContainer<TResource> container, out RootNode<TResource> node))
+            GetHookResult<TResource> result = GetHook(ResourceHook.AfterUpdate, resources);
+
+            if (result.Succeeded)
             {
-                container.AfterUpdate((HashSet<TResource>)node.UniqueResources, pipeline);
+                result.Container.AfterUpdate((HashSet<TResource>)result.Node.UniqueResources, pipeline);
             }
 
-            Traverse(_traversalHelper.CreateNextLayer(node), ResourceHook.AfterUpdateRelationship,
+            Traverse(_traversalHelper.CreateNextLayer(result.Node), ResourceHook.AfterUpdateRelationship,
                 (nextContainer, nextNode) => FireAfterUpdateRelationship(nextContainer, nextNode, pipeline));
         }
 
         /// <inheritdoc />
         public void AfterDelete<TResource>(IEnumerable<TResource> resources, ResourcePipeline pipeline, bool succeeded)
             where TResource : class, IIdentifiable
         {
-            if (GetHook(ResourceHook.AfterDelete, resources, out IResourceHookContainer<TResource> container, out RootNode<TResource> node))
+            GetHookResult<TResource> result = GetHook(ResourceHook.AfterDelete, resources);
+
+            if (result.Succeeded)
             {
-                container.AfterDelete((HashSet<TResource>)node.UniqueResources, pipeline, succeeded);
+                result.Container.AfterDelete((HashSet<TResource>)result.Node.UniqueResources, pipeline, succeeded);
             }
         }
 
@@ -212,13 +231,13 @@ public void AfterDelete<TResource>(IEnumerable<TResource> resources, ResourcePip
         /// <returns>
         /// <c>true</c>, if hook was implemented, <c>false</c> otherwise.
         /// </returns>
-        private bool GetHook<TResource>(ResourceHook target, IEnumerable<TResource> resources, out IResourceHookContainer<TResource> container,
-            out RootNode<TResource> node)
+        private GetHookResult<TResource> GetHook<TResource>(ResourceHook target, IEnumerable<TResource> resources)
             where TResource : class, IIdentifiable
         {
-            node = _traversalHelper.CreateRootNode(resources);
-            container = _executorHelper.GetResourceHookContainer<TResource>(target);
-            return container != null;
+            RootNode<TResource> node = _traversalHelper.CreateRootNode(resources);
+            IResourceHookContainer<TResource> container = _executorHelper.GetResourceHookContainer<TResource>(target);
+
+            return new GetHookResult<TResource>(container, node);
         }
 
         /// <summary>
@@ -577,5 +596,20 @@ private HashSet<string> GetIds(IEnumerable resources)
         {
             return new HashSet<string>(resources.Cast<IIdentifiable>().Select(resource => resource.StringId));
         }
+
+        private sealed class GetHookResult<TResource>
+            where TResource : class, IIdentifiable
+        {
+            public IResourceHookContainer<TResource> Container { get; }
+            public RootNode<TResource> Node { get; }
+
+            public bool Succeeded => Container != null;
+
+            public GetHookResult(IResourceHookContainer<TResource> container, RootNode<TResource> node)
+            {
+                Container = container;
+                Node = node;
+            }
+        }
     }
 }
diff --git a/src/JsonApiDotNetCore/Serialization/Building/ResponseResourceObjectBuilder.cs b/src/JsonApiDotNetCore/Serialization/Building/ResponseResourceObjectBuilder.cs
@@ -70,13 +70,13 @@ protected override RelationshipEntry GetRelationshipData(RelationshipAttribute r
             ArgumentGuard.NotNull(resource, nameof(resource));
 
             RelationshipEntry relationshipEntry = null;
-            List<IReadOnlyCollection<RelationshipAttribute>> relationshipChains = null;
+            IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> relationshipChains = GetInclusionChain(relationship);
 
-            if (Equals(relationship, _requestRelationship) || ShouldInclude(relationship, out relationshipChains))
+            if (Equals(relationship, _requestRelationship) || relationshipChains.Any())
             {
                 relationshipEntry = base.GetRelationshipData(relationship, resource);
 
-                if (relationshipChains != null && relationshipEntry.HasResource)
+                if (relationshipChains.Any() && relationshipEntry.HasResource)
                 {
                     foreach (IReadOnlyCollection<RelationshipAttribute> chain in relationshipChains)
                     {
@@ -117,7 +117,7 @@ private bool IsRelationshipInSparseFieldSet(RelationshipAttribute relationship)
         /// Inspects the included relationship chains (see <see cref="IIncludeQueryStringParameterReader" /> to see if <paramref name="relationship" /> should be
         /// included or not.
         /// </summary>
-        private bool ShouldInclude(RelationshipAttribute relationship, out List<IReadOnlyCollection<RelationshipAttribute>> inclusionChain)
+        private IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> GetInclusionChain(RelationshipAttribute relationship)
         {
             // @formatter:wrap_chained_method_calls chop_always
             // @formatter:keep_existing_linebreaks true
@@ -132,7 +132,7 @@ private bool ShouldInclude(RelationshipAttribute relationship, out List<IReadOnl
             // @formatter:keep_existing_linebreaks restore
             // @formatter:wrap_chained_method_calls restore
 
-            inclusionChain = new List<IReadOnlyCollection<RelationshipAttribute>>();
+            var inclusionChain = new List<IReadOnlyCollection<RelationshipAttribute>>();
 
             foreach (ResourceFieldChainExpression chain in chains)
             {
@@ -142,7 +142,7 @@ private bool ShouldInclude(RelationshipAttribute relationship, out List<IReadOnl
                 }
             }
 
-            return inclusionChain.Any();
+            return inclusionChain;
         }
     }
 }
diff --git a/test/UnitTests/Serialization/Server/RequestDeserializerTests.cs b/test/UnitTests/Serialization/Server/RequestDeserializerTests.cs
@@ -28,7 +28,10 @@ public RequestDeserializerTests()
         public void DeserializeAttributes_VariousUpdatedMembers_RegistersTargetedFields()
         {
             // Arrange
-            SetupFieldsManager(out HashSet<AttrAttribute> attributesToUpdate, out HashSet<RelationshipAttribute> relationshipsToUpdate);
+            var attributesToUpdate = new HashSet<AttrAttribute>();
+            var relationshipsToUpdate = new HashSet<RelationshipAttribute>();
+            SetupFieldsManager(attributesToUpdate, relationshipsToUpdate);
+
             Document content = CreateTestResourceDocument();
             string body = JsonConvert.SerializeObject(content);
 
@@ -44,7 +47,10 @@ public void DeserializeAttributes_VariousUpdatedMembers_RegistersTargetedFields(
         public void DeserializeRelationships_MultipleDependentRelationships_RegistersUpdatedRelationships()
         {
             // Arrange
-            SetupFieldsManager(out HashSet<AttrAttribute> attributesToUpdate, out HashSet<RelationshipAttribute> relationshipsToUpdate);
+            var attributesToUpdate = new HashSet<AttrAttribute>();
+            var relationshipsToUpdate = new HashSet<RelationshipAttribute>();
+            SetupFieldsManager(attributesToUpdate, relationshipsToUpdate);
+
             Document content = CreateDocumentWithRelationships("multiPrincipals");
             content.SingleData.Relationships.Add("populatedToOne", CreateRelationshipData("oneToOneDependents"));
             content.SingleData.Relationships.Add("emptyToOne", CreateRelationshipData());
@@ -64,7 +70,10 @@ public void DeserializeRelationships_MultipleDependentRelationships_RegistersUpd
         public void DeserializeRelationships_MultiplePrincipalRelationships_RegistersUpdatedRelationships()
         {
             // Arrange
-            SetupFieldsManager(out HashSet<AttrAttribute> attributesToUpdate, out HashSet<RelationshipAttribute> relationshipsToUpdate);
+            var attributesToUpdate = new HashSet<AttrAttribute>();
+            var relationshipsToUpdate = new HashSet<RelationshipAttribute>();
+            SetupFieldsManager(attributesToUpdate, relationshipsToUpdate);
+
             Document content = CreateDocumentWithRelationships("multiDependents");
             content.SingleData.Relationships.Add("populatedToOne", CreateRelationshipData("oneToOnePrincipals"));
             content.SingleData.Relationships.Add("emptyToOne", CreateRelationshipData());
@@ -80,10 +89,8 @@ public void DeserializeRelationships_MultiplePrincipalRelationships_RegistersUpd
             Assert.Empty(attributesToUpdate);
         }
 
-        private void SetupFieldsManager(out HashSet<AttrAttribute> attributesToUpdate, out HashSet<RelationshipAttribute> relationshipsToUpdate)
+        private void SetupFieldsManager(HashSet<AttrAttribute> attributesToUpdate, HashSet<RelationshipAttribute> relationshipsToUpdate)
         {
-            attributesToUpdate = new HashSet<AttrAttribute>();
-            relationshipsToUpdate = new HashSet<RelationshipAttribute>();
             _fieldsManagerMock.Setup(fields => fields.Attributes).Returns(attributesToUpdate);
             _fieldsManagerMock.Setup(fields => fields.Relationships).Returns(relationshipsToUpdate);
         }

Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,10 @@ public Dictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(Dic`
`209`	`209`
`210`	`210`	`foreach (KeyValuePair<RelationshipAttribute, IEnumerable> kvp in leftResourcesByRelation)`
`211`	`211`	`{`
`212`		`- if (IsHasManyThrough(kvp, out IEnumerable lefts, out RelationshipAttribute relationship))`
	`212`	`+ RelationshipAttribute relationship = kvp.Key;`
	`213`	`+ IEnumerable lefts = kvp.Value;`
	`214`	`+`
	`215`	`+ if (relationship is HasManyThroughAttribute)`
`213`	`216`	`{`
`214`	`217`	`continue;`
`215`	`218`	`}`
`@@ -270,12 +273,5 @@ private static void AddToList(IList list, IEnumerable itemsToAdd)`
`270`	`273`	`list.Add(item);`
`271`	`274`	`}`
`272`	`275`	`}`
`273`		`-`
`274`		`- private bool IsHasManyThrough(KeyValuePair<RelationshipAttribute, IEnumerable> kvp, out IEnumerable resources, out RelationshipAttribute attr)`
`275`		`- {`
`276`		`- attr = kvp.Key;`
`277`		`- resources = kvp.Value;`
`278`		`- return kvp.Key is HasManyThroughAttribute;`
`279`		`- }`
`280`	`276`	`}`
`281`	`277`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,13 +70,13 @@ protected override RelationshipEntry GetRelationshipData(RelationshipAttribute r`
`70`	`70`	`ArgumentGuard.NotNull(resource, nameof(resource));`
`71`	`71`
`72`	`72`	`RelationshipEntry relationshipEntry = null;`
`73`		`- List<IReadOnlyCollection<RelationshipAttribute>> relationshipChains = null;`
	`73`	`+ IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> relationshipChains = GetInclusionChain(relationship);`
`74`	`74`
`75`		`- if (Equals(relationship, _requestRelationship) \|\| ShouldInclude(relationship, out relationshipChains))`
	`75`	`+ if (Equals(relationship, _requestRelationship) \|\| relationshipChains.Any())`
`76`	`76`	`{`
`77`	`77`	`relationshipEntry = base.GetRelationshipData(relationship, resource);`
`78`	`78`
`79`		`- if (relationshipChains != null && relationshipEntry.HasResource)`
	`79`	`+ if (relationshipChains.Any() && relationshipEntry.HasResource)`
`80`	`80`	`{`
`81`	`81`	`foreach (IReadOnlyCollection<RelationshipAttribute> chain in relationshipChains)`
`82`	`82`	`{`
`@@ -117,7 +117,7 @@ private bool IsRelationshipInSparseFieldSet(RelationshipAttribute relationship)`
`117`	`117`	`/// Inspects the included relationship chains (see <see cref="IIncludeQueryStringParameterReader" /> to see if <paramref name="relationship" /> should be`
`118`	`118`	`/// included or not.`
`119`	`119`	`/// </summary>`
`120`		`- private bool ShouldInclude(RelationshipAttribute relationship, out List<IReadOnlyCollection<RelationshipAttribute>> inclusionChain)`
	`120`	`+ private IReadOnlyCollection<IReadOnlyCollection<RelationshipAttribute>> GetInclusionChain(RelationshipAttribute relationship)`
`121`	`121`	`{`
`122`	`122`	`// @formatter:wrap_chained_method_calls chop_always`
`123`	`123`	`// @formatter:keep_existing_linebreaks true`
`@@ -132,7 +132,7 @@ private bool ShouldInclude(RelationshipAttribute relationship, out List<IReadOnl`
`132`	`132`	`// @formatter:keep_existing_linebreaks restore`
`133`	`133`	`// @formatter:wrap_chained_method_calls restore`
`134`	`134`
`135`		`- inclusionChain = new List<IReadOnlyCollection<RelationshipAttribute>>();`
	`135`	`+ var inclusionChain = new List<IReadOnlyCollection<RelationshipAttribute>>();`
`136`	`136`
`137`	`137`	`foreach (ResourceFieldChainExpression chain in chains)`
`138`	`138`	`{`
`@@ -142,7 +142,7 @@ private bool ShouldInclude(RelationshipAttribute relationship, out List<IReadOnl`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`145`		`- return inclusionChain.Any();`
	`145`	`+ return inclusionChain;`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`	`}`