From 9850eb1a6a38fb1cd23be6a13433f15413cf3879 Mon Sep 17 00:00:00 2001
From: Ruslan Artamonov <r.artamonov@tbank.ru>
Date: Tue, 25 Mar 2025 11:47:10 +0300
Subject: [PATCH] Fix namespace conflict, use display format with global
 namespace style

---
 .../AddServicesTests.cs                       | 88 +++++++++----------
 .../CustomHandlerTests.cs                     | 16 ++--
 .../GeneratedMethodTests.cs                   | 12 +--
 ...jectionGenerator.FindServicesToRegister.cs | 12 +--
 4 files changed, 64 insertions(+), 64 deletions(-)

diff --git a/ServiceScan.SourceGenerator.Tests/AddServicesTests.cs b/ServiceScan.SourceGenerator.Tests/AddServicesTests.cs
index 082a14c..a3e941f 100644
--- a/ServiceScan.SourceGenerator.Tests/AddServicesTests.cs
+++ b/ServiceScan.SourceGenerator.Tests/AddServicesTests.cs
@@ -34,8 +34,8 @@ public class MyService2 : IService { }
 
         var registrations = $"""
             return services
-                .Add{lifetime}<GeneratorTests.IService, GeneratorTests.MyService1>()
-                .Add{lifetime}<GeneratorTests.IService, GeneratorTests.MyService2>();
+                .Add{lifetime}<global::GeneratorTests.IService, global::GeneratorTests.MyService1>()
+                .Add{lifetime}<global::GeneratorTests.IService, global::GeneratorTests.MyService2>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -53,8 +53,8 @@ public void AddServicesFromAnotherAssembly()
 
         var registrations = $"""
             return services
-                .AddTransient<External.IExternalService, External.ExternalService1>()
-                .AddTransient<External.IExternalService, External.ExternalService2>();
+                .AddTransient<global::External.IExternalService, global::External.ExternalService1>()
+                .AddTransient<global::External.IExternalService, global::External.ExternalService2>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -82,8 +82,8 @@ public class MyService2 : AbstractService { }
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.IService, GeneratorTests.MyService1>()
-                .AddTransient<GeneratorTests.IService, GeneratorTests.MyService2>();
+                .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService1>()
+                .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService2>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -111,8 +111,8 @@ public class MyService2 : AbstractService { }
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.BaseType, GeneratorTests.MyService1>()
-                .AddTransient<GeneratorTests.BaseType, GeneratorTests.MyService2>();
+                .AddTransient<global::GeneratorTests.BaseType, global::GeneratorTests.MyService1>()
+                .AddTransient<global::GeneratorTests.BaseType, global::GeneratorTests.MyService2>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -139,8 +139,8 @@ public class MyStringService : IService<string> { }
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.IService<int>, GeneratorTests.MyIntService>()
-                .AddTransient<GeneratorTests.IService<string>, GeneratorTests.MyStringService>();
+                .AddTransient<global::GeneratorTests.IService<int>, global::GeneratorTests.MyIntService>()
+                .AddTransient<global::GeneratorTests.IService<string>, global::GeneratorTests.MyStringService>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -167,7 +167,7 @@ public class MyStringService : IService<string> { }
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.IService<int>, GeneratorTests.MyIntService>();
+                .AddTransient<global::GeneratorTests.IService<int>, global::GeneratorTests.MyIntService>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -194,8 +194,8 @@ public class MyService2 : AbstractService { }
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.AbstractService, GeneratorTests.MyService1>()
-                .AddTransient<GeneratorTests.AbstractService, GeneratorTests.MyService2>();
+                .AddTransient<global::GeneratorTests.AbstractService, global::GeneratorTests.MyService1>()
+                .AddTransient<global::GeneratorTests.AbstractService, global::GeneratorTests.MyService2>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -222,8 +222,8 @@ public class MyService2 : AbstractService { }
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.MyService1, GeneratorTests.MyService1>()
-                .AddTransient<GeneratorTests.MyService2, GeneratorTests.MyService2>();
+                .AddTransient<global::GeneratorTests.MyService1, global::GeneratorTests.MyService1>()
+                .AddTransient<global::GeneratorTests.MyService2, global::GeneratorTests.MyService2>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -248,7 +248,7 @@ public class MyService { }
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.MyService, GeneratorTests.MyService>();
+                .AddTransient<global::GeneratorTests.MyService, global::GeneratorTests.MyService>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -275,8 +275,8 @@ public class MyStringService : AbstractService<string> { }
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.AbstractService<int>, GeneratorTests.MyIntService>()
-                .AddTransient<GeneratorTests.AbstractService<string>, GeneratorTests.MyStringService>();
+                .AddTransient<global::GeneratorTests.AbstractService<int>, global::GeneratorTests.MyIntService>()
+                .AddTransient<global::GeneratorTests.AbstractService<string>, global::GeneratorTests.MyStringService>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -303,8 +303,8 @@ public class MyService2<T> : IGenericService<T> { }
 
         var registrations = $"""
             return services
-                .AddTransient(typeof(GeneratorTests.IGenericService<>), typeof(GeneratorTests.MyService1<>))
-                .AddTransient(typeof(GeneratorTests.IGenericService<>), typeof(GeneratorTests.MyService2<>));
+                .AddTransient(typeof(global::GeneratorTests.IGenericService<>), typeof(global::GeneratorTests.MyService1<>))
+                .AddTransient(typeof(global::GeneratorTests.IGenericService<>), typeof(global::GeneratorTests.MyService2<>));
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -331,8 +331,8 @@ public class MyService2<T> : IService { }
 
         var registrations = $"""
             return services
-                .AddTransient(typeof(GeneratorTests.IService), typeof(GeneratorTests.MyService1<>))
-                .AddTransient(typeof(GeneratorTests.IService), typeof(GeneratorTests.MyService2<>));
+                .AddTransient(typeof(global::GeneratorTests.IService), typeof(global::GeneratorTests.MyService1<>))
+                .AddTransient(typeof(global::GeneratorTests.IService), typeof(global::GeneratorTests.MyService2<>));
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -360,8 +360,8 @@ public class ServiceWithNonMatchingName {}
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.MyFirstService, GeneratorTests.MyFirstService>()
-                .AddTransient<GeneratorTests.MySecondService, GeneratorTests.MySecondService>();
+                .AddTransient<global::GeneratorTests.MyFirstService, global::GeneratorTests.MyFirstService>()
+                .AddTransient<global::GeneratorTests.MySecondService, global::GeneratorTests.MySecondService>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -397,8 +397,8 @@ public class ServiceWithoutAttribute {}
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.MyFirstService, GeneratorTests.MyFirstService>()
-                .AddTransient<GeneratorTests.MySecondService, GeneratorTests.MySecondService>();
+                .AddTransient<global::GeneratorTests.MyFirstService, global::GeneratorTests.MyFirstService>()
+                .AddTransient<global::GeneratorTests.MySecondService, global::GeneratorTests.MySecondService>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -433,7 +433,7 @@ public class ServiceWithNonMatchingName {}
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.MyFirstService, GeneratorTests.MyFirstService>();
+                .AddTransient<global::GeneratorTests.MyFirstService, global::GeneratorTests.MyFirstService>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -461,8 +461,8 @@ public class ServiceWithNonMatchingName {}
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.MyFirstService, GeneratorTests.MyFirstService>()
-                .AddTransient<GeneratorTests.MySecondService, GeneratorTests.MySecondService>();
+                .AddTransient<global::GeneratorTests.MyFirstService, global::GeneratorTests.MyFirstService>()
+                .AddTransient<global::GeneratorTests.MySecondService, global::GeneratorTests.MySecondService>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -492,9 +492,9 @@ public class InterfacelessService {}
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.IServiceA, GeneratorTests.MyFirstService>()
-                .AddTransient<GeneratorTests.IServiceB, GeneratorTests.MySecondService>()
-                .AddTransient<GeneratorTests.IServiceC, GeneratorTests.MySecondService>();
+                .AddTransient<global::GeneratorTests.IServiceA, global::GeneratorTests.MyFirstService>()
+                .AddTransient<global::GeneratorTests.IServiceB, global::GeneratorTests.MySecondService>()
+                .AddTransient<global::GeneratorTests.IServiceC, global::GeneratorTests.MySecondService>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -527,9 +527,9 @@ public class MyService: IServiceA, IServiceB {}
 
         var registrations = $"""
             return services
-                .AddSingleton<GeneratorTests.MyService, GeneratorTests.MyService>()
-                .AddSingleton<GeneratorTests.IServiceA>(s => s.GetRequiredService<GeneratorTests.MyService>())
-                .AddSingleton<GeneratorTests.IServiceB>(s => s.GetRequiredService<GeneratorTests.MyService>());
+                .AddSingleton<global::GeneratorTests.MyService, global::GeneratorTests.MyService>()
+                .AddSingleton<global::GeneratorTests.IServiceA>(s => s.GetRequiredService<global::GeneratorTests.MyService>())
+                .AddSingleton<global::GeneratorTests.IServiceB>(s => s.GetRequiredService<global::GeneratorTests.MyService>());
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -563,9 +563,9 @@ public class MyService1 : IService { }
 
         var registrations = $"""
             return services
-                .AddTransient<GeneratorTests.IService, GeneratorTests.ParentType1.MyService1>()
-                .AddTransient<GeneratorTests.IService, GeneratorTests.ParentType1.MyService2>()
-                .AddTransient<GeneratorTests.IService, GeneratorTests.ParentType2.MyService1>();
+                .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.ParentType1.MyService1>()
+                .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.ParentType1.MyService2>()
+                .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.ParentType2.MyService1>();
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -595,8 +595,8 @@ public class MyService2 : IService { }
 
         var registrations = $"""
             return services
-                .AddKeyedTransient<GeneratorTests.IService, GeneratorTests.MyService1>(GetName<GeneratorTests.MyService1>())
-                .AddKeyedTransient<GeneratorTests.IService, GeneratorTests.MyService2>(GetName<GeneratorTests.MyService2>());
+                .AddKeyedTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService1>(GetName<global::GeneratorTests.MyService1>())
+                .AddKeyedTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService2>(GetName<global::GeneratorTests.MyService2>());
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -626,8 +626,8 @@ public class MyService2 : IService { }
 
         var registrations = $"""
             return services
-                .AddKeyedTransient<GeneratorTests.IService, GeneratorTests.MyService1>(GetName(typeof(GeneratorTests.MyService1)))
-                .AddKeyedTransient<GeneratorTests.IService, GeneratorTests.MyService2>(GetName(typeof(GeneratorTests.MyService2)));
+                .AddKeyedTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService1>(GetName(typeof(global::GeneratorTests.MyService1)))
+                .AddKeyedTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService2>(GetName(typeof(global::GeneratorTests.MyService2)));
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
@@ -662,8 +662,8 @@ public class MyService2 : IService
 
         var registrations = $"""
             return services
-                .AddKeyedTransient<GeneratorTests.IService, GeneratorTests.MyService1>(GeneratorTests.MyService1.Key)
-                .AddKeyedTransient<GeneratorTests.IService, GeneratorTests.MyService2>(GeneratorTests.MyService2.Key);
+                .AddKeyedTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService1>(global::GeneratorTests.MyService1.Key)
+                .AddKeyedTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService2>(global::GeneratorTests.MyService2.Key);
             """;
         Assert.Equal(Sources.GetMethodImplementation(registrations), results.GeneratedTrees[1].ToString());
     }
diff --git a/ServiceScan.SourceGenerator.Tests/CustomHandlerTests.cs b/ServiceScan.SourceGenerator.Tests/CustomHandlerTests.cs
index 578e5b6..0953565 100644
--- a/ServiceScan.SourceGenerator.Tests/CustomHandlerTests.cs
+++ b/ServiceScan.SourceGenerator.Tests/CustomHandlerTests.cs
@@ -49,8 +49,8 @@ public static partial class ServicesExtensions
             {
                 public static partial void ProcessServices()
                 {
-                    HandleType<GeneratorTests.MyService1>();
-                    HandleType<GeneratorTests.MyService2>();
+                    HandleType<global::GeneratorTests.MyService1>();
+                    HandleType<global::GeneratorTests.MyService2>();
                 }
             }
             """;
@@ -97,8 +97,8 @@ public static partial class ServicesExtensions
             {
                 public static partial void ProcessServices( string value, decimal number)
                 {
-                    HandleType<GeneratorTests.MyFirstService>(value, number);
-                    HandleType<GeneratorTests.MySecondService>(value, number);
+                    HandleType<global::GeneratorTests.MyFirstService>(value, number);
+                    HandleType<global::GeneratorTests.MySecondService>(value, number);
                 }
             }
             """;
@@ -150,8 +150,8 @@ public static partial class ServicesExtensions
             {
                 public static partial GeneratorTests.IServices ProcessServices(this GeneratorTests.IServices services)
                 {
-                    HandleType<GeneratorTests.MyService1>(services);
-                    HandleType<GeneratorTests.MyService2>(services);
+                    HandleType<global::GeneratorTests.MyService1>(services);
+                    HandleType<global::GeneratorTests.MyService2>(services);
                     return services;
                 }
             }
@@ -208,8 +208,8 @@ public static partial class ServicesExtensions
             {
                 public static partial IServiceCollection ProcessServices(this IServiceCollection services, decimal number)
                 {
-                    HandleType<GeneratorTests.MyFirstService>(services, number);
-                    HandleType<GeneratorTests.MySecondService>(services, number);
+                    HandleType<global::GeneratorTests.MyFirstService>(services, number);
+                    HandleType<global::GeneratorTests.MySecondService>(services, number);
                     return services;
                 }
             }
diff --git a/ServiceScan.SourceGenerator.Tests/GeneratedMethodTests.cs b/ServiceScan.SourceGenerator.Tests/GeneratedMethodTests.cs
index 210c6ac..2acb602 100644
--- a/ServiceScan.SourceGenerator.Tests/GeneratedMethodTests.cs
+++ b/ServiceScan.SourceGenerator.Tests/GeneratedMethodTests.cs
@@ -52,7 +52,7 @@ namespace GeneratorTests;
                 {{methodAccessModifier}} static partial IServiceCollection AddServices(this IServiceCollection services)
                 {
                     return services
-                        .AddTransient<GeneratorTests.IService, GeneratorTests.MyService>();
+                        .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService>();
                 }
             }
             """;
@@ -92,7 +92,7 @@ public static partial class ServicesExtensions
                 public static partial void AddServices(this IServiceCollection services)
                 {
                     services
-                        .AddTransient<GeneratorTests.IService, GeneratorTests.MyService>();
+                        .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService>();
                 }
             }
             """;
@@ -132,7 +132,7 @@ public static partial class ServicesExtensions
                 public static partial IServiceCollection AddServices( IServiceCollection services)
                 {
                     return services
-                        .AddTransient<GeneratorTests.IService, GeneratorTests.MyService>();
+                        .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService>();
                 }
             }
             """;
@@ -172,7 +172,7 @@ public partial class ServiceType
                 private partial void AddServices( IServiceCollection services)
                 {
                     services
-                        .AddTransient<GeneratorTests.IService, GeneratorTests.MyService>();
+                        .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService>();
                 }
             }
             """;
@@ -211,7 +211,7 @@ public static partial class ServicesExtensions
                 public static partial IServiceCollection AddServices(this IServiceCollection services)
                 {
                     return services
-                        .AddTransient<GeneratorTests.IService, GeneratorTests.MyService>();
+                        .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService>();
                 }
             }
             """;
@@ -251,7 +251,7 @@ public static partial class ServicesExtensions
                 public static partial IServiceCollection AddServices(this IServiceCollection strangeServices)
                 {
                     return strangeServices
-                        .AddTransient<GeneratorTests.IService, GeneratorTests.MyService>();
+                        .AddTransient<global::GeneratorTests.IService, global::GeneratorTests.MyService>();
                 }
             }
             """;
diff --git a/ServiceScan.SourceGenerator/DependencyInjectionGenerator.FindServicesToRegister.cs b/ServiceScan.SourceGenerator/DependencyInjectionGenerator.FindServicesToRegister.cs
index de7b396..af467ac 100644
--- a/ServiceScan.SourceGenerator/DependencyInjectionGenerator.FindServicesToRegister.cs
+++ b/ServiceScan.SourceGenerator/DependencyInjectionGenerator.FindServicesToRegister.cs
@@ -33,7 +33,7 @@ private static DiagnosticModel<MethodImplementationModel> FindServicesToRegister
 
                 if (attribute.CustomHandler != null)
                 {
-                    customHandlers.Add(new CustomHandlerModel(attribute.CustomHandler, implementationType.ToDisplayString()));
+                    customHandlers.Add(new CustomHandlerModel(attribute.CustomHandler, implementationType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)));
                 }
                 else
                 {
@@ -49,10 +49,10 @@ private static DiagnosticModel<MethodImplementationModel> FindServicesToRegister
                     {
                         if (implementationType.IsGenericType)
                         {
-                            var implementationTypeName = implementationType.ConstructUnboundGenericType().ToDisplayString();
+                            var implementationTypeName = implementationType.ConstructUnboundGenericType().ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
                             var serviceTypeName = serviceType.IsGenericType
-                                ? serviceType.ConstructUnboundGenericType().ToDisplayString()
-                                : serviceType.ToDisplayString();
+                                ? serviceType.ConstructUnboundGenericType().ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)
+                                : serviceType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 
                             var registration = new ServiceRegistrationModel(
                                 attribute.Lifetime,
@@ -70,8 +70,8 @@ private static DiagnosticModel<MethodImplementationModel> FindServicesToRegister
                             var shouldResolve = attribute.AsSelf && attribute.AsImplementedInterfaces && !SymbolEqualityComparer.Default.Equals(implementationType, serviceType);
                             var registration = new ServiceRegistrationModel(
                                 attribute.Lifetime,
-                                serviceType.ToDisplayString(),
-                                implementationType.ToDisplayString(),
+                                serviceType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat),
+                                implementationType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat),
                                 shouldResolve,
                                 false,
                                 attribute.KeySelector,