Fixed type rename issue when types where uses in nun-null types.

src/Core/Language.Tests/AST/ListTypeNodeTests.cs

@@ -0,0 +1,139 @@
+using System;
+using Xunit;
+
+namespace HotChocolate.Language
+{
+    public class ListTypeNodeTests
+    {
+        [Fact]
+        public void Create_With_Type()
+        {
+            // arrange
+            var namedType = new NamedTypeNode("abc");
+
+            // act
+            var type = new ListTypeNode(namedType);
+
+            // assert
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void Create_With_Type_Where_Type_Is_Null()
+        {
+            // arrange
+            // act
+            Action action = () => new ListTypeNode(null);
+
+            // assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        [Fact]
+        public void Create_With_Location_And_Type()
+        {
+            // arrange
+            var location = new Location(1, 1, 1, 1);
+            var namedType = new NamedTypeNode("abc");
+
+            // act
+            var type = new ListTypeNode(location, namedType);
+
+            // assert
+            Assert.Equal(location, type.Location);
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void Create_With_Location_And_Type_Where_Location_Is_Null()
+        {
+            // arrange
+            var namedType = new NamedTypeNode("abc");
+
+            // act
+            var type = new ListTypeNode(null, namedType);
+
+            // assert
+            Assert.Null(type.Location);
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void Create_With_Location_And_Type_Where_Type_Is_Null()
+        {
+            // arrange
+            var location = new Location(1, 1, 1, 1);
+
+            // act
+            Action action = () => new ListTypeNode(location, null);
+
+            // assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        [Fact]
+        public void WithLocation()
+        {
+            // arrange
+            var initialLocation = new Location(1, 1, 1, 1);
+            var namedType = new NamedTypeNode("abc");
+            var type = new ListTypeNode(initialLocation, namedType);
+
+            // act
+            var newLocation = new Location(2, 2, 2, 2);
+            type = type.WithLocation(newLocation);
+
+            // assert
+            Assert.Equal(newLocation, type.Location);
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void WithLocation_Where_Location_Is_Null()
+        {
+            // arrange
+            var initialLocation = new Location(1, 1, 1, 1);
+            var namedType = new NamedTypeNode("abc");
+            var type = new ListTypeNode(initialLocation, namedType);
+
+            // act
+            type = type.WithLocation(null);
+
+            // assert
+            Assert.Null(type.Location);
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void WithType()
+        {
+            // arrange
+            var location = new Location(1, 1, 1, 1);
+            var initialType = new NamedTypeNode("abc");
+            var type = new ListTypeNode(location, initialType);
+
+            // act
+            var newType = new NamedTypeNode("def");
+            type = type.WithType(newType);
+
+            // assert
+            Assert.Equal(location, type.Location);
+            Assert.Equal(newType, type.Type);
+        }
+
+        [Fact]
+        public void WithType_Where_Type_Is_Null()
+        {
+            // arrange
+            var location = new Location(1, 1, 1, 1);
+            var initialType = new NamedTypeNode("abc");
+            var type = new ListTypeNode(location, initialType);
+
+            // act
+            Action action = () => type.WithType(null);
+
+            // assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+    }
+}

src/Core/Language.Tests/AST/NonNullTypeNodeTests.cs

@@ -0,0 +1,139 @@
+using System;
+using Xunit;
+
+namespace HotChocolate.Language
+{
+    public class NonNullTypeNodeTests
+    {
+        [Fact]
+        public void Create_With_Type()
+        {
+            // arrange
+            var namedType = new NamedTypeNode("abc");
+
+            // act
+            var type = new NonNullTypeNode(namedType);
+
+            // assert
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void Create_With_Type_Where_Type_Is_Null()
+        {
+            // arrange
+            // act
+            Action action = () => new NonNullTypeNode(null);
+
+            // assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        [Fact]
+        public void Create_With_Location_And_Type()
+        {
+            // arrange
+            var location = new Location(1, 1, 1, 1);
+            var namedType = new NamedTypeNode("abc");
+
+            // act
+            var type = new NonNullTypeNode(location, namedType);
+
+            // assert
+            Assert.Equal(location, type.Location);
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void Create_With_Location_And_Type_Where_Location_Is_Null()
+        {
+            // arrange
+            var namedType = new NamedTypeNode("abc");
+
+            // act
+            var type = new NonNullTypeNode(null, namedType);
+
+            // assert
+            Assert.Null(type.Location);
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void Create_With_Location_And_Type_Where_Type_Is_Null()
+        {
+            // arrange
+            var location = new Location(1, 1, 1, 1);
+
+            // act
+            Action action = () => new NonNullTypeNode(location, null);
+
+            // assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        [Fact]
+        public void WithLocation()
+        {
+            // arrange
+            var initialLocation = new Location(1, 1, 1, 1);
+            var namedType = new NamedTypeNode("abc");
+            var type = new NonNullTypeNode(initialLocation, namedType);
+
+            // act
+            var newLocation = new Location(2, 2, 2, 2);
+            type = type.WithLocation(newLocation);
+
+            // assert
+            Assert.Equal(newLocation, type.Location);
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void WithLocation_Where_Location_Is_Null()
+        {
+            // arrange
+            var initialLocation = new Location(1, 1, 1, 1);
+            var namedType = new NamedTypeNode("abc");
+            var type = new NonNullTypeNode(initialLocation, namedType);
+
+            // act
+            type = type.WithLocation(null);
+
+            // assert
+            Assert.Null(type.Location);
+            Assert.Equal(namedType, type.Type);
+        }
+
+        [Fact]
+        public void WithType()
+        {
+            // arrange
+            var location = new Location(1, 1, 1, 1);
+            var initialType = new NamedTypeNode("abc");
+            var type = new NonNullTypeNode(location, initialType);
+
+            // act
+            var newType = new NamedTypeNode("def");
+            type = type.WithType(newType);
+
+            // assert
+            Assert.Equal(location, type.Location);
+            Assert.Equal(newType, type.Type);
+        }
+
+        [Fact]
+        public void WithType_Where_Type_Is_Null()
+        {
+            // arrange
+            var location = new Location(1, 1, 1, 1);
+            var initialType = new NamedTypeNode("abc");
+            var type = new NonNullTypeNode(location, initialType);
+
+            // act
+            Action action = () => type.WithType(null);
+
+            // assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+    }
+}

src/Core/Language/AST/NonNullTypeNode.cs

@@ -30,7 +30,7 @@ public NonNullTypeNode WithLocation(Location location)
 
         public NonNullTypeNode WithType(INullableTypeNode type)
         {
-            return new NonNullTypeNode(Location, Type);
+            return new NonNullTypeNode(Location, type);
         }
 
         public bool Equals(NonNullTypeNode other)

src/Stitching/Stitching.Tests/Merge/SchemaMergerTests.cs

@@ -309,6 +309,26 @@ public void RenameReferencingType()
                 SnapshotNameExtension.Create("B"));
         }
 
+        [Fact]
+        public void Rename_Type_With_Various_Variants()
+        {
+            // arrange
+            DocumentNode initial =
+                Utf8GraphQLParser.Parse(
+                    "type A { b1: B! b2: [B!] b3: [B] b4: [B!]! } " +
+                    "type B implements C { c: String } " +
+                    "interface C { c: String }");
+
+            // act
+            DocumentNode merged = SchemaMerger.New()
+                .AddSchema("A", initial)
+                .RenameType("A", "B", "Foo")
+                .Merge();
+
+            // assert
+            SchemaSyntaxSerializer.Serialize(merged).MatchSnapshot();
+        }
+
         [Fact]
         public void FieldDefinitionDoesNotHaveSameTypeShape()
         {

src/Stitching/Stitching.Tests/Merge/__snapshots__/SchemaMergerTests.Rename_Type_With_Various_Variants.snap

@@ -0,0 +1,14 @@
+type A @source(name: "A", schema: "A") {
+  b1: Foo!
+  b2: [Foo!]
+  b3: [Foo]
+  b4: [Foo!]!
+}
+
+type Foo implements C @source(name: "B", schema: "A") {
+  c: String
+}
+
+interface C @source(name: "C", schema: "A") {
+  c: String
+}

src/Stitching/Stitching/Merge/Rewriters/RenameTypeRewriter.cs

@@ -1,4 +1,3 @@
-using System;
 using HotChocolate.Language;
 
 namespace HotChocolate.Stitching.Merge.Rewriters

src/Stitching/Stitching/Merge/TypeReferenceRewriter.cs

@@ -1,9 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using HotChocolate;
 using HotChocolate.Language;
-using HotChocolate.Resolvers;
 
 namespace HotChocolate.Stitching.Merge
 {

src/Stitching/Stitching/StitchingBuilder.Factory.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using HotChocolate.Execution;
-using HotChocolate.Execution.Configuration;
 using HotChocolate.Language;
 using HotChocolate.Stitching.Client;
 using HotChocolate.Stitching.Delegation;