Merge pull request #105 from AArnott/fix104

Fully-qualify type references to IRecursiveParentWithOrderedChildren

Author: AArnott

src/ImmutableObjectGraph.Generation.Tests/TestSources/ImmutableArray.cs

@@ -1,10 +1,8 @@
-namespace ImmutableObjectGraph.Generation.Tests.TestSources
+namespace TestSources // Don't use ImmutableObjectGraph namespace so that we're testing that we fully qualify type names.
 {
-    using System.Collections.Immutable;
-
-    [GenerateImmutable]
+    [ImmutableObjectGraph.Generation.GenerateImmutable]
     partial class Node
     {
-        readonly ImmutableArray<Node> children;
+        readonly System.Collections.Immutable.ImmutableArray<Node> children;
     }
 }

src/ImmutableObjectGraph.Generation/CodeGen+DeepMutationGen.cs

@@ -183,15 +183,20 @@ private MethodDeclarationSyntax CreateRemoveDescendentMethod()
                             .AddVariables(SyntaxFactory.VariableDeclarator(newSpineVar.Identifier).WithInitializer(SyntaxFactory.EqualsValueClause(
                                 SyntaxFactory.InvocationExpression(Syntax.CreateImmutableStack(this.applyTo.RecursiveType.TypeSyntax))
                                     .AddArgumentListArguments(SyntaxFactory.Argument(newParentVar)))))),
-                        // return (TRecursiveParent)this.ReplaceDescendent(spine, newSpine, spineIncludesDeletedElement: true).Peek();
+                        // return (TRecursiveParent)ImmutableObjectGraph.RecursiveTypeExtensions.ReplaceDescendent(this, spine, newSpine, spineIncludesDeletedElement: true).Peek();
                         SyntaxFactory.ReturnStatement(
                             SyntaxFactory.CastExpression(
                                 this.applyTo.RecursiveParent.TypeSyntax,
                                 SyntaxFactory.InvocationExpression(
                                     SyntaxFactory.MemberAccessExpression(
                                         SyntaxKind.SimpleMemberAccessExpression,
-                                        SyntaxFactory.InvocationExpression(Syntax.ThisDot(ReplaceDescendentMethodName))
+                                        SyntaxFactory.InvocationExpression(
+                                            SyntaxFactory.MemberAccessExpression(
+                                                SyntaxKind.SimpleMemberAccessExpression,
+                                                Syntax.GetTypeSyntax(typeof(RecursiveTypeExtensions)),
+                                                ReplaceDescendentMethodName))
                                             .AddArgumentListArguments(
+                                                SyntaxFactory.Argument(SyntaxFactory.ThisExpression()),
                                                 SyntaxFactory.Argument(spineVar),
                                                 SyntaxFactory.Argument(newSpineVar),
                                                 SyntaxFactory.Argument(SyntaxFactory.NameColon("spineIncludesDeletedElement"), NoneToken, SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression))
@@ -229,15 +234,20 @@ private MethodDeclarationSyntax CreateReplaceDescendentSameIdentityMethod()
                                 SyntaxFactory.ThrowStatement(
                                     SyntaxFactory.ObjectCreationExpression(Syntax.GetTypeSyntax(typeof(ArgumentException))).AddArgumentListArguments(
                                         SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Old value not found."))))))),
-                        // return (TemplateType)this.ReplaceDescendent(spine, ImmutableStack.Create(updatedNode), spineIncludesDeletedElement: false).Peek();
+                        // return (TemplateType)ImmutableObjectGraph.RecursiveTypeExtensions.ReplaceDescendent(this, spine, ImmutableStack.Create(updatedNode), spineIncludesDeletedElement: false).Peek();
                         SyntaxFactory.ReturnStatement(
                             SyntaxFactory.CastExpression(
                                 this.applyTo.TypeSyntax,
                                 SyntaxFactory.InvocationExpression(
                                     SyntaxFactory.MemberAccessExpression(
                                         SyntaxKind.SimpleMemberAccessExpression,
-                                        SyntaxFactory.InvocationExpression(Syntax.ThisDot(ReplaceDescendentMethodName))
+                                        SyntaxFactory.InvocationExpression(
+                                            SyntaxFactory.MemberAccessExpression(
+                                                SyntaxKind.SimpleMemberAccessExpression,
+                                                Syntax.GetTypeSyntax(typeof(RecursiveTypeExtensions)),
+                                                ReplaceDescendentMethodName))
                                             .AddArgumentListArguments(
+                                                SyntaxFactory.Argument(SyntaxFactory.ThisExpression()),
                                                 SyntaxFactory.Argument(spineVar),
                                                 SyntaxFactory.Argument(SyntaxFactory.InvocationExpression(Syntax.CreateImmutableStack()).AddArgumentListArguments(
                                                     SyntaxFactory.Argument(updatedNodeParameter))),
@@ -278,15 +288,20 @@ private MethodDeclarationSyntax CreateReplaceDescendentDifferentIdentityMethod()
                                 SyntaxFactory.ThrowStatement(
                                     SyntaxFactory.ObjectCreationExpression(Syntax.GetTypeSyntax(typeof(ArgumentException))).AddArgumentListArguments(
                                         SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Old value not found."))))))),
-                        // return (TemplateType)this.ReplaceDescendent(spine, ImmutableStack.Create(replacement), spineIncludesDeletedElement: false).Peek();
+                        // return (TemplateType)ImmutableObjectGraph.RecursiveTypeExtensions.ReplaceDescendent(this, spine, ImmutableStack.Create(replacement), spineIncludesDeletedElement: false).Peek();
                         SyntaxFactory.ReturnStatement(
                             SyntaxFactory.CastExpression(
                                 this.applyTo.TypeSyntax,
                                 SyntaxFactory.InvocationExpression(
                                     SyntaxFactory.MemberAccessExpression(
                                         SyntaxKind.SimpleMemberAccessExpression,
-                                        SyntaxFactory.InvocationExpression(Syntax.ThisDot(ReplaceDescendentMethodName))
+                                        SyntaxFactory.InvocationExpression(
+                                            SyntaxFactory.MemberAccessExpression(
+                                                SyntaxKind.SimpleMemberAccessExpression,
+                                                Syntax.GetTypeSyntax(typeof(RecursiveTypeExtensions)),
+                                                ReplaceDescendentMethodName))
                                             .AddArgumentListArguments(
+                                                SyntaxFactory.Argument(SyntaxFactory.ThisExpression()),
                                                 SyntaxFactory.Argument(spineVar),
                                                 SyntaxFactory.Argument(SyntaxFactory.InvocationExpression(Syntax.CreateImmutableStack()).AddArgumentListArguments(
                                                     SyntaxFactory.Argument(replacementParameter))),

src/ImmutableObjectGraph.Generation/CodeGen+EnumerableRecursiveParentGen.cs

@@ -62,13 +62,17 @@ private MethodDeclarationSyntax CreateGetParentMethod()
                     .AddAttributeLists(PureAttributeList)
                     .AddParameterListParameters(SyntaxFactory.Parameter(descendentParam.Identifier).WithType(this.applyTo.RecursiveType.TypeSyntax))
                     .WithBody(SyntaxFactory.Block(
-                        // return this.GetParent<TRecursiveParent, TRecursiveType>(descendent);
+                        // return ImmutableObjectGraph.RecursiveTypeExtensions.GetParent<TRecursiveParent, TRecursiveType>(this, descendent);
                         SyntaxFactory.ReturnStatement(
                             SyntaxFactory.InvocationExpression(
-                                Syntax.ThisDot(
+                                SyntaxFactory.MemberAccessExpression(
+                                    SyntaxKind.SimpleMemberAccessExpression,
+                                    Syntax.GetTypeSyntax(typeof(RecursiveTypeExtensions)),
                                     SyntaxFactory.GenericName(nameof(RecursiveTypeExtensions.GetParent))
                                         .AddTypeArgumentListArguments(this.applyTo.RecursiveParent.TypeSyntax, this.applyTo.RecursiveType.TypeSyntax)))
-                                .AddArgumentListArguments(SyntaxFactory.Argument(descendentParam)))));
+                                .AddArgumentListArguments(
+                                    SyntaxFactory.Argument(SyntaxFactory.ThisExpression()),
+                                    SyntaxFactory.Argument(descendentParam)))));
             }
 
             private void ImplementIEnumerableInterfaces()
@@ -129,25 +133,32 @@ private void ImplementRecursiveParentInterface()
                     .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
                     .AddAttributeLists(SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(DebuggerBrowsableNeverAttribute))));
 
-                // public ParentedRecursiveType<TRecursiveParent, TRecursiveType> GetParentedNode(uint identity)
+                // public ImmutableObjectGraph.ParentedRecursiveType<TRecursiveParent, TRecursiveType> GetParentedNode(uint identity)
                 this.innerMembers.Add(
                     SyntaxFactory.MethodDeclaration(
-                        SyntaxFactory.GenericName(nameof(ParentedRecursiveType<IRecursiveParent<IRecursiveType>, IRecursiveType>)).AddTypeArgumentListArguments(
-                            this.applyTo.RecursiveParent.TypeSyntax,
-                            this.applyTo.RecursiveType.TypeSyntax),
+                        SyntaxFactory.QualifiedName(
+                            SyntaxFactory.IdentifierName(nameof(ImmutableObjectGraph)),
+                            SyntaxFactory.GenericName(nameof(ParentedRecursiveType<IRecursiveParent<IRecursiveType>, IRecursiveType>)).AddTypeArgumentListArguments(
+                                this.applyTo.RecursiveParent.TypeSyntax,
+                                this.applyTo.RecursiveType.TypeSyntax)),
                         nameof(IRecursiveParent.GetParentedNode))
                     .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
                     .AddAttributeLists(PureAttributeList)
                     //.WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(Syntax.GetTypeSyntax(typeof(IRecursiveParent))))
                     .AddParameterListParameters(RequiredIdentityParameter)
                     .WithBody(SyntaxFactory.Block(
-                        // return this.GetParentedNode<TRecursiveParent, TRecursiveType>(identity);
+                        // return ImmutableObjectGraph.RecursiveTypeExtensions.GetParentedNode<TRecursiveParent, TRecursiveType>(this, identity);
                         SyntaxFactory.ReturnStatement(
                             SyntaxFactory.InvocationExpression(
-                                Syntax.ThisDot(SyntaxFactory.GenericName(nameof(RecursiveTypeExtensions.GetParentedNode)).AddTypeArgumentListArguments(
-                                    this.applyTo.RecursiveParent.TypeSyntax,
-                                    this.applyTo.RecursiveType.TypeSyntax)))
-                                .AddArgumentListArguments(SyntaxFactory.Argument(IdentityParameterName))))));
+                                SyntaxFactory.MemberAccessExpression(
+                                    SyntaxKind.SimpleMemberAccessExpression,
+                                    Syntax.GetTypeSyntax(typeof(RecursiveTypeExtensions)),
+                                    SyntaxFactory.GenericName(nameof(RecursiveTypeExtensions.GetParentedNode)).AddTypeArgumentListArguments(
+                                        this.applyTo.RecursiveParent.TypeSyntax,
+                                        this.applyTo.RecursiveType.TypeSyntax)))
+                                .AddArgumentListArguments(
+                                    SyntaxFactory.Argument(SyntaxFactory.ThisExpression()),
+                                    SyntaxFactory.Argument(IdentityParameterName))))));
 
                 // ParentedRecursiveType<IRecursiveParent<IRecursiveType>, IRecursiveType> IRecursiveParent.GetParentedNode(<#= templateType.RequiredIdentityField.TypeName #> identity) {
                 var parentedVar = SyntaxFactory.IdentifierName("parented");
@@ -194,7 +205,7 @@ private void ImplementOrderedChildrenInterface()
                 this.innerMembers.Add(SyntaxFactory.PropertyDeclaration(
                     Syntax.IReadOnlyListOf(Syntax.GetTypeSyntax(typeof(IRecursiveType))),
                     nameof(IRecursiveParentWithOrderedChildren.Children))
-                    .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(SyntaxFactory.IdentifierName(nameof(IRecursiveParentWithOrderedChildren))))
+                    .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(Syntax.GetTypeSyntax(typeof(IRecursiveParentWithOrderedChildren))))
                     .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(Syntax.ThisDot(SyntaxFactory.IdentifierName(this.generator.applyToMetaType.RecursiveField.Name))))
                     .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
                     .AddAttributeLists(SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(DebuggerBrowsableNeverAttribute))));
@@ -204,7 +215,7 @@ private void ImplementOrderedChildrenInterface()
                 this.innerMembers.Add(SyntaxFactory.MethodDeclaration(
                     SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
                     nameof(IRecursiveParentWithOrderedChildren.IndexOf))
-                    .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(SyntaxFactory.IdentifierName(nameof(IRecursiveParentWithOrderedChildren))))
+                    .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(Syntax.GetTypeSyntax(typeof(IRecursiveParentWithOrderedChildren))))
                     .AddParameterListParameters(SyntaxFactory.Parameter(valueParameterName.Identifier).WithType(Syntax.GetTypeSyntax(typeof(IRecursiveType))))
                     .WithBody(SyntaxFactory.Block(
                         // return this.Children.IndexOf((<#= templateType.RecursiveType.TypeName #>)value);