Ensure two interfaces with the same name do not cause compile errors

InterfaceStubGenerator.Shared/InterfaceStubGenerator.cs

@@ -90,7 +90,7 @@
         /// <param name="candidateMethods">The candidate methods.</param>
         /// <param name="candidateInterfaces">The candidate interfaces.</param>
         /// <returns></returns>
         public void GenerateInterfaceStubs<TContext>(
             TContext context,
             Action<TContext, Diagnostic> reportDiagnostic,
             Action<TContext, string, SourceText> addSource,
@@ -105,7 +105,7 @@
 
             // we're going to create a new compilation that contains the attribute.
             // TODO: we should allow source generators to provide source during initialize, so that this step isn't required.
             var options = (CSharpParseOptions)compilation.SyntaxTrees[0].Options;
 
             var disposableInterfaceSymbol = compilation.GetTypeByMetadataName(
                 "System.IDisposable"
@@ -116,7 +116,7 @@
 
             if (httpMethodBaseAttributeSymbol == null)
             {
                 reportDiagnostic(context, Diagnostic.Create(RefitNotReferenced, null));
                 return;
             }
 
@@ -222,7 +222,7 @@
             );
 
             // add the attribute text
             addSource(
                 context,
                 "PreserveAttribute.g.cs",
                 SourceText.From(attributeText, Encoding.UTF8)
@@ -291,7 +291,8 @@
                 );
 
                 var keyName = group.Key.Name;
-                if (keyCount.TryGetValue(keyName, out var value))
+                int value;
+                while(keyCount.TryGetValue(keyName, out value))
                 {
                     keyName = $"{keyName}{++value}";
                 }
@@ -583,7 +584,7 @@
             bool isOverrideOrExplicitImplementation
         )
         {
-            // Explicit interface implementations and ovverrides can only have class or struct constraints
+            // Explicit interface implementations and overrides can only have class or struct constraints
 
             var parameters = new List<string>();
             if (typeParameter.HasReferenceTypeConstraint)
@@ -875,7 +876,7 @@
             context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
         }
 
         class SyntaxReceiver : ISyntaxReceiver
         {
             public List<MethodDeclarationSyntax> CandidateMethods { get; } = new();
 

Refit.Tests/NamespaceCollisionApi.cs

@@ -23,9 +23,21 @@ public static INamespaceCollisionApi Create()
 namespace CollisionA
 {
     public class SomeType { }
+
+    public interface INamespaceCollisionApi
+    {
+        [Get("/")]
+        Task<SomeType> SomeRequest();
+    }
 }
 
 namespace CollisionB
 {
     public class SomeType { }
+
+    public interface INamespaceCollisionApi
+    {
+        [Get("/")]
+        Task<SomeType> SomeRequest();
+    }
 }

Refit.Tests/RestService.cs

@@ -2199,28 +2199,31 @@ public void NonGenericCreate()
         Assert.Equal(fixture.Client.BaseAddress.AbsoluteUri, expectedBaseAddress);
     }
 
-    [Fact]
-    public async Task TypeCollisionTest()
-    {
-        var mockHttp = new MockHttpMessageHandler();
+        [Fact]
+        public async Task TypeCollisionTest()
+        {
+            var mockHttp = new MockHttpMessageHandler();
 
-        var settings = new RefitSettings { HttpMessageHandlerFactory = () => mockHttp, };
+            var settings = new RefitSettings { HttpMessageHandlerFactory = () => mockHttp, };
 
-        const string Url = "https://httpbin.org/get";
+            const string Url = "https://httpbin.org/get";
 
-        mockHttp.Expect(HttpMethod.Get, Url).Respond("application/json", "{ }");
+            mockHttp.Expect(HttpMethod.Get, Url).Respond("application/json", "{ }");
 
-        var fixtureA = RestService.For<ITypeCollisionApiA>(Url);
+            var fixtureA = RestService.For<ITypeCollisionApiA>(Url, settings);
 
-        var respA = await fixtureA.SomeARequest();
+            var respA = await fixtureA.SomeARequest();
 
-        var fixtureB = RestService.For<ITypeCollisionApiB>(Url);
+            mockHttp.Expect(HttpMethod.Get, Url)
+                .Respond("application/json", "{ }");
 
-        var respB = await fixtureB.SomeBRequest();
+            var fixtureB = RestService.For<ITypeCollisionApiB>(Url, settings);
 
-        Assert.IsType<CollisionA.SomeType>(respA);
-        Assert.IsType<CollisionB.SomeType>(respB);
-    }
+            var respB = await fixtureB.SomeBRequest();
+
+            Assert.IsType<CollisionA.SomeType>(respA);
+            Assert.IsType<CollisionB.SomeType>(respB);
+        }
 
     internal static Stream GetTestFileStream(string relativeFilePath)
     {
@@ -2261,10 +2264,48 @@ internal static Stream GetTestFileStream(string relativeFilePath)
         return stream;
     }
 
-    public void AssertFirstLineContains(string expectedSubstring, string actualString)
-    {
-        var eolIndex = actualString.IndexOf('\n');
-        var firstLine = eolIndex < 0 ? actualString : actualString.Substring(0, eolIndex);
-        Assert.Contains(expectedSubstring, firstLine);
-    }
+        [Fact]
+        public async Task SameTypeNameInMultipleNamespacesTest()
+        {
+            var mockHttp = new MockHttpMessageHandler();
+
+            var settings = new RefitSettings
+            {
+                HttpMessageHandlerFactory = () => mockHttp,
+            };
+
+            const string Url = "https://httpbin.org/get";
+
+            mockHttp.Expect(HttpMethod.Get, Url + "/")
+                .Respond("application/json", "{ }");
+
+            var fixtureA = RestService.For<INamespaceCollisionApi>(Url, settings);
+
+            var respA = await fixtureA.SomeRequest();
+
+            mockHttp.Expect(HttpMethod.Get, Url + "/")
+                .Respond("application/json", "{ }");
+
+            var fixtureB = RestService.For<CollisionA.INamespaceCollisionApi>(Url, settings);
+
+            var respB = await fixtureB.SomeRequest();
+
+            mockHttp.Expect(HttpMethod.Get, Url + "/")
+                .Respond("application/json", "{ }");
+
+            var fixtureC = RestService.For<CollisionB.INamespaceCollisionApi>(Url, settings);
+
+            var respC = await fixtureC.SomeRequest();
+
+            Assert.IsType<CollisionA.SomeType>(respA);
+            Assert.IsType<CollisionA.SomeType>(respB);
+            Assert.IsType<CollisionB.SomeType>(respC);
+        }
+
+        public void AssertFirstLineContains(string expectedSubstring, string actualString)
+        {
+            var eolIndex = actualString.IndexOf('\n');
+            var firstLine = eolIndex < 0 ? actualString : actualString.Substring(0, eolIndex);
+            Assert.Contains(expectedSubstring, firstLine);
+        }
 }