Use IReadOnlyCollection over IEnumerable

AArnott · AArnott · commit 944cc78e1cce · 2016-07-04T07:19:19.000-06:00
diff --git a/src/ImmutableObjectGraph.Generation/CodeGen+EnumerableRecursiveParentGen.cs b/src/ImmutableObjectGraph.Generation/CodeGen+EnumerableRecursiveParentGen.cs
@@ -115,10 +115,10 @@ private void ImplementRecursiveParentInterface()
                 // this.Children;
                 var thisDotChildren = Syntax.ThisDot(SyntaxFactory.IdentifierName(this.generator.applyToMetaType.RecursiveField.Name.ToPascalCase()));
 
-                // System.Collections.Generic.IEnumerable<IRecursiveType> IRecursiveParent.Children
+                // System.Collections.Generic.IReadOnlyCollection<IRecursiveType> IRecursiveParent.Children
                 this.innerMembers.Add(
                     SyntaxFactory.PropertyDeclaration(
-                        Syntax.GetTypeSyntax(typeof(IEnumerable<IRecursiveType>)),
+                        Syntax.GetTypeSyntax(typeof(IReadOnlyCollection<IRecursiveType>)),
                         nameof(IRecursiveParent.Children))
                     .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(Syntax.GetTypeSyntax(typeof(IRecursiveParent))))
                     .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(thisDotChildren))
@@ -164,11 +164,11 @@ private void ImplementRecursiveParentInterface()
                             SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, parentedVar, SyntaxFactory.IdentifierName(nameof(ParentedRecursiveTypeNonGeneric.Value)))),
                             SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, parentedVar, SyntaxFactory.IdentifierName(nameof(ParentedRecursiveTypeNonGeneric.Parent)))))))));
 
-                ////System.Collections.Generic.IEnumerable<<#= templateType.RecursiveType.TypeName #>> IRecursiveParent<<#= templateType.RecursiveType.TypeName #>>.Children
+                ////System.Collections.Generic.IReadOnlyCollection<<#= templateType.RecursiveType.TypeName #>> IRecursiveParent<<#= templateType.RecursiveType.TypeName #>>.Children
                 ////	=> return this.Children;
                 this.innerMembers.Add(
                     SyntaxFactory.PropertyDeclaration(
-                        Syntax.IEnumerableOf(this.generator.applyToMetaType.RecursiveType.TypeSyntax),
+                        Syntax.IReadOnlyCollectionOf(this.generator.applyToMetaType.RecursiveType.TypeSyntax),
                         nameof(IRecursiveParent<IRecursiveType>.Children))
                     .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(irecursiveParentOfT))
                     .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(thisDotChildren))
@@ -185,6 +185,15 @@ private void ImplementOrderedChildrenInterface()
                     this.baseTypes.Add(SyntaxFactory.SimpleBaseType(Syntax.GetTypeSyntax(typeof(IRecursiveParentWithOrderedChildren))));
                 }
 
+                // IReadOnlyList<IRecursiveType> IRecursiveParentWithOrderedChildren.Children => this.children;
+                this.innerMembers.Add(SyntaxFactory.PropertyDeclaration(
+                    Syntax.IReadOnlyListOf(Syntax.GetTypeSyntax(typeof(IRecursiveType))),
+                    nameof(IRecursiveParentWithOrderedChildren.Children))
+                    .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(SyntaxFactory.IdentifierName(nameof(IRecursiveParentWithOrderedChildren))))
+                    .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(Syntax.ThisDot(SyntaxFactory.IdentifierName(this.generator.applyToMetaType.RecursiveField.Name))))
+                    .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
+                    .AddAttributeLists(SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(DebuggerBrowsableNeverAttribute))));
+
                 // int IRecursiveParentWithOrderedChildren.IndexOf(IRecursiveType value)
                 var valueParameterName = SyntaxFactory.IdentifierName("value");
                 this.innerMembers.Add(SyntaxFactory.MethodDeclaration(
diff --git a/src/ImmutableObjectGraph.Generation/CodeGen+RootedStructGen.cs b/src/ImmutableObjectGraph.Generation/CodeGen+RootedStructGen.cs
@@ -743,21 +743,17 @@ protected MethodDeclarationSyntax CreateParentedNodeMethod()
             protected PropertyDeclarationSyntax[] CreateChildrenProperties()
             {
                 return new PropertyDeclarationSyntax[] {
-                    // IEnumerable<IRecursiveType> IRecursiveParent.Children { get; }
-                    SyntaxFactory.PropertyDeclaration(Syntax.IEnumerableOf(Syntax.GetTypeSyntax(typeof(IRecursiveType))), nameof(IRecursiveParent.Children))
+                    // IReadOnlyCollection<IRecursiveType> IRecursiveParent.Children => this.greenNode.Children;
+                    SyntaxFactory.PropertyDeclaration(Syntax.IReadOnlyCollectionOf(Syntax.GetTypeSyntax(typeof(IRecursiveType))), nameof(IRecursiveParent.Children))
                         .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(Syntax.GetTypeSyntax(typeof(IRecursiveParent))))
-                        .AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(
-                            SyntaxKind.GetAccessorDeclaration,
-                            SyntaxFactory.Block(
-                                // return System.Linq.Enumerable.Cast<IRecursiveType>(this.Children);
-                                SyntaxFactory.ReturnStatement(
-                                    Syntax.EnumerableExtension(
-                                        SyntaxFactory.GenericName(nameof(Enumerable.Cast))
-                                            .AddTypeArgumentListArguments(Syntax.GetTypeSyntax(typeof(IRecursiveType))),
-                                        Syntax.ThisDot(this.applyTo.RecursiveParent.RecursiveField.NameAsProperty),
-                                        SyntaxFactory.ArgumentList()))))),
-                    // IEnumerable<TRootedRecursiveType> IRecursiveParent<TRootedRecursiveType>.Children { get; }
-                    SyntaxFactory.PropertyDeclaration(Syntax.IEnumerableOf(this.rootedRecursiveType), nameof(IRecursiveParent<IRecursiveType>.Children))
+                        .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(
+                            SyntaxFactory.MemberAccessExpression(
+                                SyntaxKind.SimpleMemberAccessExpression,
+                                Syntax.ThisDot(GreenNodeFieldName),
+                                this.applyTo.RecursiveParent.RecursiveField.NameAsProperty)))
+                        .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
+                    // IReadOnlyCollection<TRootedRecursiveType> IRecursiveParent<TRootedRecursiveType>.Children { get; }
+                    SyntaxFactory.PropertyDeclaration(Syntax.IReadOnlyCollectionOf(this.rootedRecursiveType), nameof(IRecursiveParent<IRecursiveType>.Children))
                         .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(CreateIRecursiveParentOfTSyntax(this.rootedRecursiveType)))
                         // => this.Children;
                         .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(Syntax.ThisDot(this.applyTo.RecursiveParent.RecursiveField.NameAsProperty)))
diff --git a/src/ImmutableObjectGraph/IRecursiveCollection.cs b/src/ImmutableObjectGraph/IRecursiveCollection.cs
@@ -13,14 +13,14 @@ public interface IRecursiveType {
 	}
 
 	public interface IRecursiveParent : IRecursiveType {
-		IEnumerable<IRecursiveType> Children { get; }
+		IReadOnlyCollection<IRecursiveType> Children { get; }
 
 		ParentedRecursiveType<IRecursiveParent<IRecursiveType>, IRecursiveType> GetParentedNode(IdentityFieldType identity);
 	}
 
 	public interface IRecursiveParent<out TRecursiveType> : IRecursiveParent
 		where TRecursiveType : IRecursiveType {
-		new IEnumerable<TRecursiveType> Children { get; }
+		new IReadOnlyCollection<TRecursiveType> Children { get; }
 	}
 
     public interface IRecursiveParentWithChildReplacement<TRecursiveType> : IRecursiveParent
@@ -30,11 +30,13 @@ public interface IRecursiveParentWithChildReplacement<TRecursiveType> : IRecursi
     }
 
 	public interface IRecursiveParentWithOrderedChildren : IRecursiveParent {
-		int IndexOf(IRecursiveType value);
+        new IReadOnlyList<IRecursiveType> Children { get; }
+
+        int IndexOf(IRecursiveType value);
 	}
 
 	public interface IRecursiveParentWithSortedChildren : IRecursiveParentWithOrderedChildren {
-		int Compare(IRecursiveType first, IRecursiveType second);
+        int Compare(IRecursiveType first, IRecursiveType second);
 	}
 
     public interface IRecursiveParentWithLookupTable<TRecursiveType> : IRecursiveParent<TRecursiveType>
diff --git a/src/ImmutableObjectGraph/RecursiveTypeExtensions.cs b/src/ImmutableObjectGraph/RecursiveTypeExtensions.cs
@@ -292,10 +292,10 @@ public static IEnumerable<TRecursiveType> GetSelfAndDescendentsBreadthFirst<TRec
                 var visiting = nodesToVisit.Dequeue();
                 yield return visiting;
 
-                var visitingAsParent = visiting as IRecursiveParent;
+                var visitingAsParent = visiting as IRecursiveParent<TRecursiveType>;
                 if (visitingAsParent != null && visitingAsParent.Children != null)
                 {
-                    foreach (TRecursiveType child in visitingAsParent.Children)
+                    foreach (var child in visitingAsParent.Children)
                     {
                         nodesToVisit.Enqueue(child);
                     }

Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,14 @@ public interface IRecursiveType {`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`public interface IRecursiveParent : IRecursiveType {`
`16`		`- IEnumerable<IRecursiveType> Children { get; }`
	`16`	`+ IReadOnlyCollection<IRecursiveType> Children { get; }`
`17`	`17`
`18`	`18`	`ParentedRecursiveType<IRecursiveParent<IRecursiveType>, IRecursiveType> GetParentedNode(IdentityFieldType identity);`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public interface IRecursiveParent<out TRecursiveType> : IRecursiveParent`
`22`	`22`	`where TRecursiveType : IRecursiveType {`
`23`		`- new IEnumerable<TRecursiveType> Children { get; }`
	`23`	`+ new IReadOnlyCollection<TRecursiveType> Children { get; }`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public interface IRecursiveParentWithChildReplacement<TRecursiveType> : IRecursiveParent`
`@@ -30,11 +30,13 @@ public interface IRecursiveParentWithChildReplacement<TRecursiveType> : IRecursi`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`public interface IRecursiveParentWithOrderedChildren : IRecursiveParent {`
`33`		`- int IndexOf(IRecursiveType value);`
	`33`	`+ new IReadOnlyList<IRecursiveType> Children { get; }`
	`34`	`+`
	`35`	`+ int IndexOf(IRecursiveType value);`
`34`	`36`	`}`
`35`	`37`
`36`	`38`	`public interface IRecursiveParentWithSortedChildren : IRecursiveParentWithOrderedChildren {`
`37`		`- int Compare(IRecursiveType first, IRecursiveType second);`
	`39`	`+ int Compare(IRecursiveType first, IRecursiveType second);`
`38`	`40`	`}`
`39`	`41`
`40`	`42`	`public interface IRecursiveParentWithLookupTable<TRecursiveType> : IRecursiveParent<TRecursiveType>`
Original file line number	Diff line number	Diff line change
`@@ -292,10 +292,10 @@ public static IEnumerable<TRecursiveType> GetSelfAndDescendentsBreadthFirst<TRec`
`292`	`292`	`var visiting = nodesToVisit.Dequeue();`
`293`	`293`	`yield return visiting;`
`294`	`294`
`295`		`- var visitingAsParent = visiting as IRecursiveParent;`
	`295`	`+ var visitingAsParent = visiting as IRecursiveParent<TRecursiveType>;`
`296`	`296`	`if (visitingAsParent != null && visitingAsParent.Children != null)`
`297`	`297`	`{`
`298`		`- foreach (TRecursiveType child in visitingAsParent.Children)`
	`298`	`+ foreach (var child in visitingAsParent.Children)`
`299`	`299`	`{`
`300`	`300`	`nodesToVisit.Enqueue(child);`
`301`	`301`	`}`