MapsterTool added global:: prefix when PrintFullTypeName enable

src/ExpressionTranslator/ExpressionTranslator.cs

@@ -537,7 +537,7 @@ private string GetTypeName(Type type)
         private string GetSingleTypeName(Type type)
         {
             var name = type.DeclaringType == null && Definitions?.PrintFullTypeName == true
-                ? type.FullName!
+                ? $"global::{type.FullName!}"
                 : type.Name;
             if (!type.GetTypeInfo().IsGenericType)
             {

src/Mapster.Tool.Tests/Helpers/CompileValidatior.cs

@@ -0,0 +1,50 @@
+using Mapster.Tool.Tests;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Emit;
+using System.Linq.Expressions;
+
+public class CompileValidator
+{
+    public static bool TryCompile(string code, out string errors)
+    {
+        SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code);
+
+        string basePath = Path.GetDirectoryName(typeof(object).Assembly.Location)!;
+
+        var references = new[]
+        {
+            MetadataReference.CreateFromFile(Path.Combine(basePath, "System.Private.CoreLib.dll")),
+            MetadataReference.CreateFromFile(Path.Combine(basePath, "System.Runtime.dll")),
+            MetadataReference.CreateFromFile(typeof(Console).Assembly.Location), 
+            MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
+            MetadataReference.CreateFromFile(typeof(TestBase).Assembly.Location),
+            MetadataReference.CreateFromFile(typeof(Expression).Assembly.Location)
+        };
+
+        CSharpCompilation compilation = CSharpCompilation.Create(
+            assemblyName: "Generated_" + Guid.NewGuid().ToString("N"), 
+            syntaxTrees: new[] { syntaxTree },
+            references: references,
+            options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+        );
+
+        using (var ms = new MemoryStream())
+        {
+            EmitResult result = compilation.Emit(ms);
+
+            if (result.Success)
+            {
+                errors = string.Empty;
+                return true;
+            }
+            else
+            {
+                errors = string.Join(Environment.NewLine, result.Diagnostics
+                    .Where(d => d.Severity == DiagnosticSeverity.Error || d.Severity == DiagnosticSeverity.Warning)
+                    .Select(d => $"{d.Id}: {d.GetMessage()}"));
+                return false;
+            }
+        }
+    }
+}

src/Mapster.Tool.Tests/Mapster.Tool.Tests.csproj

@@ -10,6 +10,7 @@
 
     <ItemGroup>
         <PackageReference Include="FluentAssertions" Version="7.0.0" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="5.9.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
         <PackageReference Include="Scrutor" Version="5.0.2" />
         <PackageReference Include="xunit" Version="2.9.2" />

src/Mapster.Tool.Tests/MapsterToolConfigTests.cs

@@ -0,0 +1,32 @@
+using FluentAssertions;
+
+namespace Mapster.Tool.Tests
+{
+    public class MapsterToolConfigTests : TestBase
+    {
+        [Fact]
+        public void PrintFullTypeName_option_True_GenerateCodeWithGlobalNamespacePreffix()
+        {
+            var mappersWithGlobal = new List<string>();
+            var mapperConfig = ConfigHelpers.optMappers;
+
+            mapperConfig.PrintFullTypeName = true;
+            Generators.GenerateMappers(mapperConfig, mappersWithGlobal);
+
+            CompileValidator.TryCompile(mappersWithGlobal[0], out string Errors).Should().BeTrue();
+            mappersWithGlobal[0].Contains("global::").Should().BeTrue();
+        }
+
+        [Fact]
+        public void PrintFullTypeName_option_False_NotGenerateCodeWithGlobalNamespacePreffix()
+        {
+            var mappersWithGlobal = new List<string>();
+            var mapperConfig = ConfigHelpers.optMappers;
+
+            mapperConfig.PrintFullTypeName = false;
+            Generators.GenerateMappers(mapperConfig, mappersWithGlobal);
+
+            mappersWithGlobal[0].Contains("global::").Should().BeFalse();
+        }
+    }
+}