diff --git a/SolutionProperties/ReleaseNotes.txt b/SolutionProperties/ReleaseNotes.txt
index 2587182..45e147c 100644
--- a/SolutionProperties/ReleaseNotes.txt
+++ b/SolutionProperties/ReleaseNotes.txt
@@ -1 +1 @@
-- Updated Microsoft.CodeAnalysis.CSharp.Workspaces package.
+- Fixed missing `global::` prefix for the underlying callee.
diff --git a/Tests/Tum4ik.StinimGen.Specs/Features/Event/Event.feature b/Tests/Tum4ik.StinimGen.Specs/Features/Event/Event.feature
index 2c442aa..dab5fa8 100644
--- a/Tests/Tum4ik.StinimGen.Specs/Features/Event/Event.feature
+++ b/Tests/Tum4ik.StinimGen.Specs/Features/Event/Event.feature
@@ -32,13 +32,13 @@ Scenario: Event field with EventHandler type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.EventMember"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.EventMember"/>
     event global::System.EventHandler EventMember;
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public event global::System.EventHandler EventMember { add => Events.EventHolder.EventMember += value; remove => Events.EventHolder.EventMember -= value; }
+    public event global::System.EventHandler EventMember { add => global::Events.EventHolder.EventMember += value; remove => global::Events.EventHolder.EventMember -= value; }
     """
 
 
@@ -51,13 +51,13 @@ Scenario: Event field with custom type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.EventMember"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.EventMember"/>
     event global::Events.CustomEventHandler EventMember;
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public event global::Events.CustomEventHandler EventMember { add => Events.EventHolder.EventMember += value; remove => Events.EventHolder.EventMember -= value; }
+    public event global::Events.CustomEventHandler EventMember { add => global::Events.EventHolder.EventMember += value; remove => global::Events.EventHolder.EventMember -= value; }
     """
 
 
@@ -70,13 +70,13 @@ Scenario: Event field with Action type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.EventMember"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.EventMember"/>
     event global::System.Action EventMember;
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public event global::System.Action EventMember { add => Events.EventHolder.EventMember += value; remove => Events.EventHolder.EventMember -= value; }
+    public event global::System.Action EventMember { add => global::Events.EventHolder.EventMember += value; remove => global::Events.EventHolder.EventMember -= value; }
     """
 
 
@@ -89,13 +89,13 @@ Scenario: Event field with Action type with keyworded generic parameter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.EventMember"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.EventMember"/>
     event global::System.Action<int> EventMember;
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public event global::System.Action<int> EventMember { add => Events.EventHolder.EventMember += value; remove => Events.EventHolder.EventMember -= value; }
+    public event global::System.Action<int> EventMember { add => global::Events.EventHolder.EventMember += value; remove => global::Events.EventHolder.EventMember -= value; }
     """
 
 
@@ -108,13 +108,13 @@ Scenario: Event field with Action type with keyworded nullable generic parameter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.EventMember"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.EventMember"/>
     event global::System.Action<string?> EventMember;
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public event global::System.Action<string?> EventMember { add => Events.EventHolder.EventMember += value; remove => Events.EventHolder.EventMember -= value; }
+    public event global::System.Action<string?> EventMember { add => global::Events.EventHolder.EventMember += value; remove => global::Events.EventHolder.EventMember -= value; }
     """
 
 
@@ -127,13 +127,13 @@ Scenario: Event field with Action type with non-keyworded generic parameter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.EventMember"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.EventMember"/>
     event global::System.Action<global::System.DateTime> EventMember;
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public event global::System.Action<global::System.DateTime> EventMember { add => Events.EventHolder.EventMember += value; remove => Events.EventHolder.EventMember -= value; }
+    public event global::System.Action<global::System.DateTime> EventMember { add => global::Events.EventHolder.EventMember += value; remove => global::Events.EventHolder.EventMember -= value; }
     """
 
 
@@ -146,13 +146,13 @@ Scenario: Event field with Action type with non-keyworded nullable generic param
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.EventMember"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.EventMember"/>
     event global::System.Action<global::System.DayOfWeek?> EventMember;
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public event global::System.Action<global::System.DayOfWeek?> EventMember { add => Events.EventHolder.EventMember += value; remove => Events.EventHolder.EventMember -= value; }
+    public event global::System.Action<global::System.DayOfWeek?> EventMember { add => global::Events.EventHolder.EventMember += value; remove => global::Events.EventHolder.EventMember -= value; }
     """
 
 
@@ -165,13 +165,13 @@ Scenario: Event field with Func
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.EventMember"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.EventMember"/>
     event global::System.Func<global::System.DayOfWeek?, double, int?> EventMember;
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public event global::System.Func<global::System.DayOfWeek?, double, int?> EventMember { add => Events.EventHolder.EventMember += value; remove => Events.EventHolder.EventMember -= value; }
+    public event global::System.Func<global::System.DayOfWeek?, double, int?> EventMember { add => global::Events.EventHolder.EventMember += value; remove => global::Events.EventHolder.EventMember -= value; }
     """
 
 
@@ -189,13 +189,13 @@ Scenario: Full event
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.FullEvent"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.FullEvent"/>
     event global::System.EventHandler FullEvent;
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public event global::System.EventHandler FullEvent { add => Events.EventHolder.FullEvent += value; remove => Events.EventHolder.FullEvent -= value; }
+    public event global::System.EventHandler FullEvent { add => global::Events.EventHolder.FullEvent += value; remove => global::Events.EventHolder.FullEvent -= value; }
     """
 
 
@@ -209,7 +209,7 @@ Scenario: Forward Obsolete attribute
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Events.EventHolder.ObsoleteEvent"/>
+    /// <inheritdoc cref = "global::Events.EventHolder.ObsoleteEvent"/>
     [global::System.ObsoleteAttribute("Obsolete event")]
     event global::System.EventHandler ObsoleteEvent;
     """
@@ -217,5 +217,5 @@ Scenario: Forward Obsolete attribute
     """
     /// <inheritdoc/>
     [global::System.ObsoleteAttribute("Obsolete event")]
-    public event global::System.EventHandler ObsoleteEvent { add => Events.EventHolder.ObsoleteEvent += value; remove => Events.EventHolder.ObsoleteEvent -= value; }
+    public event global::System.EventHandler ObsoleteEvent { add => global::Events.EventHolder.ObsoleteEvent += value; remove => global::Events.EventHolder.ObsoleteEvent -= value; }
     """
diff --git a/Tests/Tum4ik.StinimGen.Specs/Features/Field/ConstField.feature b/Tests/Tum4ik.StinimGen.Specs/Features/Field/ConstField.feature
index d127029..54a8134 100644
--- a/Tests/Tum4ik.StinimGen.Specs/Features/Field/ConstField.feature
+++ b/Tests/Tum4ik.StinimGen.Specs/Features/Field/ConstField.feature
@@ -30,13 +30,13 @@ Scenario: Field with keyworded type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.ConstField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.ConstField"/>
     int ConstField { get; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public int ConstField { get => Fields.FieldHolder.ConstField; }
+    public int ConstField { get => global::Fields.FieldHolder.ConstField; }
     """
 
 
@@ -49,11 +49,11 @@ Scenario: Field with non-keyworded type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.ConstField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.ConstField"/>
     double ConstField { get; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public double ConstField { get => Fields.FieldHolder.ConstField; }
+    public double ConstField { get => global::Fields.FieldHolder.ConstField; }
     """
diff --git a/Tests/Tum4ik.StinimGen.Specs/Features/Field/Field.feature b/Tests/Tum4ik.StinimGen.Specs/Features/Field/Field.feature
index b7f9d68..703aae9 100644
--- a/Tests/Tum4ik.StinimGen.Specs/Features/Field/Field.feature
+++ b/Tests/Tum4ik.StinimGen.Specs/Features/Field/Field.feature
@@ -30,13 +30,13 @@ Scenario: Non-nullable field with keyworded type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.StaticField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.StaticField"/>
     object StaticField { get; set; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public object StaticField { get => Fields.FieldHolder.StaticField; set => Fields.FieldHolder.StaticField = value; }
+    public object StaticField { get => global::Fields.FieldHolder.StaticField; set => global::Fields.FieldHolder.StaticField = value; }
     """
   
 
@@ -49,13 +49,13 @@ Scenario: Nullable field with keyworded type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.StaticField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.StaticField"/>
     object? StaticField { get; set; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public object? StaticField { get => Fields.FieldHolder.StaticField; set => Fields.FieldHolder.StaticField = value; }
+    public object? StaticField { get => global::Fields.FieldHolder.StaticField; set => global::Fields.FieldHolder.StaticField = value; }
     """
   
 
@@ -68,13 +68,13 @@ Scenario: Non-nullable field
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.StaticField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.StaticField"/>
     global::System.Delegate StaticField { get; set; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Delegate StaticField { get => Fields.FieldHolder.StaticField; set => Fields.FieldHolder.StaticField = value; }
+    public global::System.Delegate StaticField { get => global::Fields.FieldHolder.StaticField; set => global::Fields.FieldHolder.StaticField = value; }
     """
   
 
@@ -87,13 +87,13 @@ Scenario: Nullable field
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.StaticField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.StaticField"/>
     global::System.Delegate? StaticField { get; set; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Delegate? StaticField { get => Fields.FieldHolder.StaticField; set => Fields.FieldHolder.StaticField = value; }
+    public global::System.Delegate? StaticField { get => global::Fields.FieldHolder.StaticField; set => global::Fields.FieldHolder.StaticField = value; }
     """
 
 
@@ -107,7 +107,7 @@ Scenario: Forward Obsolete attribute
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.ObsoleteField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.ObsoleteField"/>
     [global::System.ObsoleteAttribute("Obsolete field")]
     object ObsoleteField { get; set; }
     """
@@ -115,5 +115,5 @@ Scenario: Forward Obsolete attribute
     """
     /// <inheritdoc/>
     [global::System.ObsoleteAttribute("Obsolete field")]
-    public object ObsoleteField { get => Fields.FieldHolder.ObsoleteField; set => Fields.FieldHolder.ObsoleteField = value; }
+    public object ObsoleteField { get => global::Fields.FieldHolder.ObsoleteField; set => global::Fields.FieldHolder.ObsoleteField = value; }
     """
diff --git a/Tests/Tum4ik.StinimGen.Specs/Features/Field/ReadonlyField.feature b/Tests/Tum4ik.StinimGen.Specs/Features/Field/ReadonlyField.feature
index ec8857c..d243529 100644
--- a/Tests/Tum4ik.StinimGen.Specs/Features/Field/ReadonlyField.feature
+++ b/Tests/Tum4ik.StinimGen.Specs/Features/Field/ReadonlyField.feature
@@ -30,13 +30,13 @@ Scenario: Non-nullable field with keyworded type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.StaticReadonlyField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.StaticReadonlyField"/>
     float StaticReadonlyField { get; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public float StaticReadonlyField { get => Fields.FieldHolder.StaticReadonlyField; }
+    public float StaticReadonlyField { get => global::Fields.FieldHolder.StaticReadonlyField; }
     """
   
 
@@ -49,13 +49,13 @@ Scenario: Nullable field with keyworded type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.StaticReadonlyField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.StaticReadonlyField"/>
     float? StaticReadonlyField { get; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public float? StaticReadonlyField { get => Fields.FieldHolder.StaticReadonlyField; }
+    public float? StaticReadonlyField { get => global::Fields.FieldHolder.StaticReadonlyField; }
     """
   
 
@@ -68,13 +68,13 @@ Scenario: Non-nullable field
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.StaticReadonlyField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.StaticReadonlyField"/>
     global::System.StringComparer StaticReadonlyField { get; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.StringComparer StaticReadonlyField { get => Fields.FieldHolder.StaticReadonlyField; }
+    public global::System.StringComparer StaticReadonlyField { get => global::Fields.FieldHolder.StaticReadonlyField; }
     """
   
 
@@ -87,11 +87,11 @@ Scenario: Nullable field
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Fields.FieldHolder.StaticReadonlyField"/>
+    /// <inheritdoc cref = "global::Fields.FieldHolder.StaticReadonlyField"/>
     global::System.StringComparer? StaticReadonlyField { get; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.StringComparer? StaticReadonlyField { get => Fields.FieldHolder.StaticReadonlyField; }
+    public global::System.StringComparer? StaticReadonlyField { get => global::Fields.FieldHolder.StaticReadonlyField; }
     """
diff --git a/Tests/Tum4ik.StinimGen.Specs/Features/Method/GenericMethod.feature b/Tests/Tum4ik.StinimGen.Specs/Features/Method/GenericMethod.feature
index 8bdf444..7ffc847 100644
--- a/Tests/Tum4ik.StinimGen.Specs/Features/Method/GenericMethod.feature
+++ b/Tests/Tum4ik.StinimGen.Specs/Features/Method/GenericMethod.feature
@@ -33,13 +33,13 @@ Scenario: Void method with a generic parameter and without parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method{T}()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method{T}()"/>
     void Method<T>();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method<T>() => Methods.MethodHolder.Method<T>();
+    public void Method<T>() => global::Methods.MethodHolder.Method<T>();
     """
 
 
@@ -52,13 +52,13 @@ Scenario: Void method with several generic parameters and without parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method{T1, T2, T3}()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method{T1, T2, T3}()"/>
     void Method<T1, T2, T3>();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method<T1, T2, T3>() => Methods.MethodHolder.Method<T1, T2, T3>();
+    public void Method<T1, T2, T3>() => global::Methods.MethodHolder.Method<T1, T2, T3>();
     """
 
 
@@ -71,13 +71,13 @@ Scenario: Method without parameters returns generic type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method{T}()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method{T}()"/>
     T Method<T>();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public T Method<T>() => Methods.MethodHolder.Method<T>();
+    public T Method<T>() => global::Methods.MethodHolder.Method<T>();
     """
 
 
@@ -90,13 +90,13 @@ Scenario: Method with parameters returns generic type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method{T1, T2}(T1, T2)"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method{T1, T2}(T1, T2)"/>
     T1 Method<T1, T2>(T1 p1, T2 p2);
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public T1 Method<T1, T2>(T1 p1, T2 p2) => Methods.MethodHolder.Method<T1, T2>(p1, p2);
+    public T1 Method<T1, T2>(T1 p1, T2 p2) => global::Methods.MethodHolder.Method<T1, T2>(p1, p2);
     """
 
 
@@ -109,13 +109,13 @@ Scenario: Async method without parameters returns Task of generic type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.MethodAsync{T}()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.MethodAsync{T}()"/>
     global::System.Threading.Tasks.Task<T> MethodAsync<T>();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Threading.Tasks.Task<T> MethodAsync<T>() => Methods.MethodHolder.MethodAsync<T>();
+    public global::System.Threading.Tasks.Task<T> MethodAsync<T>() => global::Methods.MethodHolder.MethodAsync<T>();
     """
 
 
@@ -128,7 +128,7 @@ Scenario: Generic method with a constraint
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method{T}()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method{T}()"/>
     void Method<T>()
         where T : class, new();
     """
@@ -136,7 +136,7 @@ Scenario: Generic method with a constraint
     """
     /// <inheritdoc/>
     public void Method<T>()
-        where T : class, new() => Methods.MethodHolder.Method<T>();
+        where T : class, new() => global::Methods.MethodHolder.Method<T>();
     """
 
 
@@ -152,7 +152,7 @@ Scenario: Generic method with several constraints
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method{TParent, TChild}()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method{TParent, TChild}()"/>
     void Method<TParent, TChild>()
         where TParent : class where TChild : TParent, new();
     """
@@ -160,5 +160,5 @@ Scenario: Generic method with several constraints
     """
     /// <inheritdoc/>
     public void Method<TParent, TChild>()
-        where TParent : class where TChild : TParent, new() => Methods.MethodHolder.Method<TParent, TChild>();
+        where TParent : class where TChild : TParent, new() => global::Methods.MethodHolder.Method<TParent, TChild>();
     """
diff --git a/Tests/Tum4ik.StinimGen.Specs/Features/Method/RegularMethod.feature b/Tests/Tum4ik.StinimGen.Specs/Features/Method/RegularMethod.feature
index e3c9cde..8571ddf 100644
--- a/Tests/Tum4ik.StinimGen.Specs/Features/Method/RegularMethod.feature
+++ b/Tests/Tum4ik.StinimGen.Specs/Features/Method/RegularMethod.feature
@@ -35,13 +35,13 @@ Scenario: Void method without parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method()"/>
     void Method();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method() => Methods.MethodHolder.Method();
+    public void Method() => global::Methods.MethodHolder.Method();
     """
 
 
@@ -54,13 +54,13 @@ Scenario: Method without parameters returns keyworded type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method()"/>
     global::System.String Method();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.String Method() => Methods.MethodHolder.Method();
+    public global::System.String Method() => global::Methods.MethodHolder.Method();
     """
 
 
@@ -73,13 +73,13 @@ Scenario: Method without parameters returns keyworded nullable type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method()"/>
     global::System.String? Method();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.String? Method() => Methods.MethodHolder.Method();
+    public global::System.String? Method() => global::Methods.MethodHolder.Method();
     """
 
 
@@ -92,13 +92,13 @@ Scenario: Method without parameters returns non-nullable type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method()"/>
     global::System.Text.StringBuilder Method();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Text.StringBuilder Method() => Methods.MethodHolder.Method();
+    public global::System.Text.StringBuilder Method() => global::Methods.MethodHolder.Method();
     """
 
 
@@ -111,13 +111,13 @@ Scenario: Method without parameters returns nullable type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method()"/>
     global::System.Text.StringBuilder? Method();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Text.StringBuilder? Method() => Methods.MethodHolder.Method();
+    public global::System.Text.StringBuilder? Method() => global::Methods.MethodHolder.Method();
     """
 
 
@@ -130,13 +130,13 @@ Scenario: Async void method without parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.MethodAsync()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.MethodAsync()"/>
     void MethodAsync();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void MethodAsync() => Methods.MethodHolder.MethodAsync();
+    public void MethodAsync() => global::Methods.MethodHolder.MethodAsync();
     """
 
 
@@ -149,13 +149,13 @@ Scenario: Async method without parameters returns Task
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.MethodAsync()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.MethodAsync()"/>
     global::System.Threading.Tasks.Task MethodAsync();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Threading.Tasks.Task MethodAsync() => Methods.MethodHolder.MethodAsync();
+    public global::System.Threading.Tasks.Task MethodAsync() => global::Methods.MethodHolder.MethodAsync();
     """
 
 
@@ -168,13 +168,13 @@ Scenario: Method without parameters returns Taks of keyworded type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.MethodAsync()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.MethodAsync()"/>
     global::System.Threading.Tasks.Task<global::System.String> MethodAsync();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Threading.Tasks.Task<global::System.String> MethodAsync() => Methods.MethodHolder.MethodAsync();
+    public global::System.Threading.Tasks.Task<global::System.String> MethodAsync() => global::Methods.MethodHolder.MethodAsync();
     """
 
 
@@ -187,13 +187,13 @@ Scenario: Method without parameters returns Task of keyworded nullable type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.MethodAsync()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.MethodAsync()"/>
     global::System.Threading.Tasks.Task<global::System.String?> MethodAsync();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Threading.Tasks.Task<global::System.String?> MethodAsync() => Methods.MethodHolder.MethodAsync();
+    public global::System.Threading.Tasks.Task<global::System.String?> MethodAsync() => global::Methods.MethodHolder.MethodAsync();
     """
 
 
@@ -206,13 +206,13 @@ Scenario: Method without parameters returns Task of non-nullable type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.MethodAsync()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.MethodAsync()"/>
     global::System.Threading.Tasks.Task<global::System.Text.StringBuilder> MethodAsync();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Threading.Tasks.Task<global::System.Text.StringBuilder> MethodAsync() => Methods.MethodHolder.MethodAsync();
+    public global::System.Threading.Tasks.Task<global::System.Text.StringBuilder> MethodAsync() => global::Methods.MethodHolder.MethodAsync();
     """
 
 
@@ -225,13 +225,13 @@ Scenario: Method without parameters returns Task of nullable type
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.MethodAsync()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.MethodAsync()"/>
     global::System.Threading.Tasks.Task<global::System.Text.StringBuilder?> MethodAsync();
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Threading.Tasks.Task<global::System.Text.StringBuilder?> MethodAsync() => Methods.MethodHolder.MethodAsync();
+    public global::System.Threading.Tasks.Task<global::System.Text.StringBuilder?> MethodAsync() => global::Methods.MethodHolder.MethodAsync();
     """
 
 
@@ -244,13 +244,13 @@ Scenario: Void method with a parameter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method(global::System.Int32)"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method(global::System.Int32)"/>
     void Method(global::System.Int32 p);
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method(global::System.Int32 p) => Methods.MethodHolder.Method(p);
+    public void Method(global::System.Int32 p) => global::Methods.MethodHolder.Method(p);
     """
 
 
@@ -263,13 +263,13 @@ Scenario: Void method with default parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method(global::System.Int32, global::System.String, global::System.Int32)"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method(global::System.Int32, global::System.String, global::System.Int32)"/>
     void Method(global::System.Int32 p1, global::System.String p2 = "def", global::System.Int32 p3 = 10);
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method(global::System.Int32 p1, global::System.String p2 = "def", global::System.Int32 p3 = 10) => Methods.MethodHolder.Method(p1, p2, p3);
+    public void Method(global::System.Int32 p1, global::System.String p2 = "def", global::System.Int32 p3 = 10) => global::Methods.MethodHolder.Method(p1, p2, p3);
     """
 
 
@@ -282,13 +282,13 @@ Scenario: Void method with several keyworded parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method(global::System.Int32, global::System.String[], global::System.Single? , global::System.Double? [], global::System.Object[] ? )"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method(global::System.Int32, global::System.String[], global::System.Single? , global::System.Double? [], global::System.Object[] ? )"/>
     void Method(global::System.Int32 p1, global::System.String[] p2, global::System.Single? p3, global::System.Double? [] p4, global::System.Object[]? p5);
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method(global::System.Int32 p1, global::System.String[] p2, global::System.Single? p3, global::System.Double? [] p4, global::System.Object[]? p5) => Methods.MethodHolder.Method(p1, p2, p3, p4, p5);
+    public void Method(global::System.Int32 p1, global::System.String[] p2, global::System.Single? p3, global::System.Double? [] p4, global::System.Object[]? p5) => global::Methods.MethodHolder.Method(p1, p2, p3, p4, p5);
     """
 
 
@@ -301,13 +301,13 @@ Scenario: Void method with several non-keyworded parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method(global::System.DateTime, global::System.DateTime[], global::System.DateTime? , global::System.DateTime? [], global::System.DateTime[] ? )"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method(global::System.DateTime, global::System.DateTime[], global::System.DateTime? , global::System.DateTime? [], global::System.DateTime[] ? )"/>
     void Method(global::System.DateTime p1, global::System.DateTime[] p2, global::System.DateTime? p3, global::System.DateTime? [] p4, global::System.DateTime[]? p5);
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method(global::System.DateTime p1, global::System.DateTime[] p2, global::System.DateTime? p3, global::System.DateTime? [] p4, global::System.DateTime[]? p5) => Methods.MethodHolder.Method(p1, p2, p3, p4, p5);
+    public void Method(global::System.DateTime p1, global::System.DateTime[] p2, global::System.DateTime? p3, global::System.DateTime? [] p4, global::System.DateTime[]? p5) => global::Methods.MethodHolder.Method(p1, p2, p3, p4, p5);
     """
 
 
@@ -320,13 +320,13 @@ Scenario: Void method with several keyworded generic parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method(global::System.Collections.Generic.List{global::System.Int32}, global::System.Collections.Generic.List{global::System.String[]}, global::System.Collections.Generic.List{global::System.Single?}, global::System.Collections.Generic.List{global::System.Double? []}, global::System.Collections.Generic.List{global::System.Object[]?  } )"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method(global::System.Collections.Generic.List{global::System.Int32}, global::System.Collections.Generic.List{global::System.String[]}, global::System.Collections.Generic.List{global::System.Single?}, global::System.Collections.Generic.List{global::System.Double? []}, global::System.Collections.Generic.List{global::System.Object[]?  } )"/>
     void Method(global::System.Collections.Generic.List<global::System.Int32> p1, global::System.Collections.Generic.List<global::System.String[]> p2, global::System.Collections.Generic.List<global::System.Single?> p3, global::System.Collections.Generic.List<global::System.Double? []> p4, global::System.Collections.Generic.List<global::System.Object[]?> p5);
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method(global::System.Collections.Generic.List<global::System.Int32> p1, global::System.Collections.Generic.List<global::System.String[]> p2, global::System.Collections.Generic.List<global::System.Single?> p3, global::System.Collections.Generic.List<global::System.Double? []> p4, global::System.Collections.Generic.List<global::System.Object[]?> p5) => Methods.MethodHolder.Method(p1, p2, p3, p4, p5);
+    public void Method(global::System.Collections.Generic.List<global::System.Int32> p1, global::System.Collections.Generic.List<global::System.String[]> p2, global::System.Collections.Generic.List<global::System.Single?> p3, global::System.Collections.Generic.List<global::System.Double? []> p4, global::System.Collections.Generic.List<global::System.Object[]?> p5) => global::Methods.MethodHolder.Method(p1, p2, p3, p4, p5);
     """
 
 
@@ -339,13 +339,13 @@ Scenario: Void method with several non-keyworded generic parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method(global::System.Collections.Generic.List{global::System.DateTime}, global::System.Collections.Generic.List{global::System.DateTime[]}, global::System.Collections.Generic.List{global::System.DateTime?}, global::System.Collections.Generic.List{global::System.DateTime? []}, global::System.Collections.Generic.List{global::System.DateTime[]?  } )"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method(global::System.Collections.Generic.List{global::System.DateTime}, global::System.Collections.Generic.List{global::System.DateTime[]}, global::System.Collections.Generic.List{global::System.DateTime?}, global::System.Collections.Generic.List{global::System.DateTime? []}, global::System.Collections.Generic.List{global::System.DateTime[]?  } )"/>
     void Method(global::System.Collections.Generic.List<global::System.DateTime> p1, global::System.Collections.Generic.List<global::System.DateTime[]> p2, global::System.Collections.Generic.List<global::System.DateTime?> p3, global::System.Collections.Generic.List<global::System.DateTime? []> p4, global::System.Collections.Generic.List<global::System.DateTime[]?> p5);
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method(global::System.Collections.Generic.List<global::System.DateTime> p1, global::System.Collections.Generic.List<global::System.DateTime[]> p2, global::System.Collections.Generic.List<global::System.DateTime?> p3, global::System.Collections.Generic.List<global::System.DateTime? []> p4, global::System.Collections.Generic.List<global::System.DateTime[]?> p5) => Methods.MethodHolder.Method(p1, p2, p3, p4, p5);
+    public void Method(global::System.Collections.Generic.List<global::System.DateTime> p1, global::System.Collections.Generic.List<global::System.DateTime[]> p2, global::System.Collections.Generic.List<global::System.DateTime?> p3, global::System.Collections.Generic.List<global::System.DateTime? []> p4, global::System.Collections.Generic.List<global::System.DateTime[]?> p5) => global::Methods.MethodHolder.Method(p1, p2, p3, p4, p5);
     """
 
 
@@ -358,13 +358,13 @@ Scenario: Void method with ref/out/in and params parameters
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.Method(ref global::System.Int32, out global::System.Double? , in global::System.DateTime, global::System.DateTime? [])"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.Method(ref global::System.Int32, out global::System.Double? , in global::System.DateTime, global::System.DateTime? [])"/>
     void Method(ref global::System.Int32 refP, out global::System.Double? outP, in global::System.DateTime inP, params global::System.DateTime? [] paramsP);
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public void Method(ref global::System.Int32 refP, out global::System.Double? outP, in global::System.DateTime inP, params global::System.DateTime? [] paramsP) => Methods.MethodHolder.Method(ref refP, out outP, in inP, paramsP);
+    public void Method(ref global::System.Int32 refP, out global::System.Double? outP, in global::System.DateTime inP, params global::System.DateTime? [] paramsP) => global::Methods.MethodHolder.Method(ref refP, out outP, in inP, paramsP);
     """
 
 
@@ -378,7 +378,7 @@ Scenario: Forward Obsolete attribute
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.ObsoleteMethod()"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.ObsoleteMethod()"/>
     [global::System.ObsoleteAttribute("Obsolete method")]
     void ObsoleteMethod();
     """
@@ -386,7 +386,7 @@ Scenario: Forward Obsolete attribute
     """
     /// <inheritdoc/>
     [global::System.ObsoleteAttribute("Obsolete method")]
-    public void ObsoleteMethod() => Methods.MethodHolder.ObsoleteMethod();
+    public void ObsoleteMethod() => global::Methods.MethodHolder.ObsoleteMethod();
     """
 
 
@@ -403,11 +403,11 @@ Scenario: Forward parameters attributes
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Methods.MethodHolder.TryParse(global::System.String? , out global::System.Int32)"/>
+    /// <inheritdoc cref = "global::Methods.MethodHolder.TryParse(global::System.String? , out global::System.Int32)"/>
     global::System.Boolean TryParse([global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] global::System.String? s, [global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)][global::System.Diagnostics.CodeAnalysis.DisallowNullAttribute][global::System.Diagnostics.CodeAnalysis.AllowNullAttribute] out global::System.Int32 result);
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.Boolean TryParse([global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] global::System.String? s, [global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)][global::System.Diagnostics.CodeAnalysis.DisallowNullAttribute][global::System.Diagnostics.CodeAnalysis.AllowNullAttribute] out global::System.Int32 result) => Methods.MethodHolder.TryParse(s, out result);
+    public global::System.Boolean TryParse([global::System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] global::System.String? s, [global::System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)][global::System.Diagnostics.CodeAnalysis.DisallowNullAttribute][global::System.Diagnostics.CodeAnalysis.AllowNullAttribute] out global::System.Int32 result) => global::Methods.MethodHolder.TryParse(s, out result);
     """
diff --git a/Tests/Tum4ik.StinimGen.Specs/Features/Property/Property.feature b/Tests/Tum4ik.StinimGen.Specs/Features/Property/Property.feature
index d0842d3..8947390 100644
--- a/Tests/Tum4ik.StinimGen.Specs/Features/Property/Property.feature
+++ b/Tests/Tum4ik.StinimGen.Specs/Features/Property/Property.feature
@@ -31,13 +31,13 @@ Scenario: Property with only getter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Properties.PropertyHolder.Property"/>
+    /// <inheritdoc cref = "global::Properties.PropertyHolder.Property"/>
     int Property { get; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public int Property { get => Properties.PropertyHolder.Property; }
+    public int Property { get => global::Properties.PropertyHolder.Property; }
     """
   
 
@@ -51,13 +51,13 @@ Scenario: Property with only setter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Properties.PropertyHolder.Property"/>
+    /// <inheritdoc cref = "global::Properties.PropertyHolder.Property"/>
     float? Property { set; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public float? Property { set => Properties.PropertyHolder.Property = value; }
+    public float? Property { set => global::Properties.PropertyHolder.Property = value; }
     """
   
 
@@ -70,13 +70,13 @@ Scenario: Property with getter and setter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Properties.PropertyHolder.Property"/>
+    /// <inheritdoc cref = "global::Properties.PropertyHolder.Property"/>
     global::System.IO.Stream Property { get; set; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.IO.Stream Property { get => Properties.PropertyHolder.Property; set => Properties.PropertyHolder.Property = value; }
+    public global::System.IO.Stream Property { get => global::Properties.PropertyHolder.Property; set => global::Properties.PropertyHolder.Property = value; }
     """
   
 
@@ -89,13 +89,13 @@ Scenario: Property with getter and private setter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Properties.PropertyHolder.Property"/>
+    /// <inheritdoc cref = "global::Properties.PropertyHolder.Property"/>
     global::System.IO.Stream? Property { get; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.IO.Stream? Property { get => Properties.PropertyHolder.Property; }
+    public global::System.IO.Stream? Property { get => global::Properties.PropertyHolder.Property; }
     """
   
 
@@ -108,13 +108,13 @@ Scenario: Property with getter and protected setter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Properties.PropertyHolder.Property"/>
+    /// <inheritdoc cref = "global::Properties.PropertyHolder.Property"/>
     global::System.IO.Stream? Property { get; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public global::System.IO.Stream? Property { get => Properties.PropertyHolder.Property; }
+    public global::System.IO.Stream? Property { get => global::Properties.PropertyHolder.Property; }
     """
   
 
@@ -127,13 +127,13 @@ Scenario: Property with private getter and setter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Properties.PropertyHolder.Property"/>
+    /// <inheritdoc cref = "global::Properties.PropertyHolder.Property"/>
     float? Property { set; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public float? Property { set => Properties.PropertyHolder.Property = value; }
+    public float? Property { set => global::Properties.PropertyHolder.Property = value; }
     """
 
 
@@ -147,13 +147,13 @@ Scenario: Property with protected getter and setter
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Properties.PropertyHolder.Property"/>
+    /// <inheritdoc cref = "global::Properties.PropertyHolder.Property"/>
     string Property { set; }
     """
   And generated implementation member must be
     """
     /// <inheritdoc/>
-    public string Property { set => Properties.PropertyHolder.Property = value; }
+    public string Property { set => global::Properties.PropertyHolder.Property = value; }
     """
 
 
@@ -167,7 +167,7 @@ Scenario: Forward Obsolete attribute
   Then there must not be generation exception
   And generated interface member must be
     """
-    /// <inheritdoc cref = "Properties.PropertyHolder.ObsoleteProperty"/>
+    /// <inheritdoc cref = "global::Properties.PropertyHolder.ObsoleteProperty"/>
     [global::System.ObsoleteAttribute("Obsolete property")]
     int ObsoleteProperty { get; }
     """
@@ -175,5 +175,5 @@ Scenario: Forward Obsolete attribute
     """
     /// <inheritdoc/>
     [global::System.ObsoleteAttribute("Obsolete property")]
-    public int ObsoleteProperty { get => Properties.PropertyHolder.ObsoleteProperty; }
+    public int ObsoleteProperty { get => global::Properties.PropertyHolder.ObsoleteProperty; }
     """
diff --git a/Tum4ik.StinimGen/Extensions/SymbolExtensions.cs b/Tum4ik.StinimGen/Extensions/SymbolExtensions.cs
index c2f7189..2ba07d1 100644
--- a/Tum4ik.StinimGen/Extensions/SymbolExtensions.cs
+++ b/Tum4ik.StinimGen/Extensions/SymbolExtensions.cs
@@ -5,6 +5,17 @@
 namespace Tum4ik.StinimGen.Extensions;
 internal static class SymbolExtensions
 {
+  /// <summary>
+  /// Gets the fully qualified name for a given symbol
+  /// </summary>
+  /// <param name="symbol">The input <see cref="ISymbol"/> instance.</param>
+  /// <returns>The fully qualified name for <paramref name="symbol"/>.</returns>
+  public static string GetFullyQualifiedName(this ISymbol symbol)
+  {
+    return symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+  }
+
+
   /// <summary>
   /// Gets the fully qualified name for a given symbol, including nullability annotations
   /// </summary>
diff --git a/Tum4ik.StinimGen/Extensions/TypeSymbolExtensions.cs b/Tum4ik.StinimGen/Extensions/TypeSymbolExtensions.cs
index 303a60f..9b62afb 100644
--- a/Tum4ik.StinimGen/Extensions/TypeSymbolExtensions.cs
+++ b/Tum4ik.StinimGen/Extensions/TypeSymbolExtensions.cs
@@ -1,60 +1,9 @@
 using System.Collections.Immutable;
-using System.Text;
 using Microsoft.CodeAnalysis;
 
 namespace Tum4ik.StinimGen.Extensions;
 internal static class TypeSymbolExtensions
 {
-  /// <summary>
-  /// Gets the fully qualified metadata name for a given <see cref="ITypeSymbol"/> instance.
-  /// </summary>
-  /// <param name="symbol">The input <see cref="ITypeSymbol"/> instance.</param>
-  /// <returns>The fully qualified metadata name for <paramref name="symbol"/>.</returns>
-  public static string GetFullyQualifiedMetadataName(this ITypeSymbol symbol)
-  {
-    var builder = new StringBuilder();
-    symbol.AppendFullyQualifiedMetadataName(builder);
-    return builder.ToString();
-  }
-
-  private static void AppendFullyQualifiedMetadataName(this ISymbol symbol, StringBuilder builder)
-  {
-    switch (symbol)
-    {
-      // Namespaces that are nested also append a leading '.'
-      case INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: false }:
-        AppendFullyQualifiedMetadataName(symbol.ContainingNamespace, builder);
-        builder.Append('.');
-        builder.Append(symbol.MetadataName);
-        break;
-
-      // Other namespaces (ie. the one right before global) skip the leading '.'
-      case INamespaceSymbol { IsGlobalNamespace: false }:
-        builder.Append(symbol.MetadataName);
-        break;
-
-      // Types with no namespace just have their metadata name directly written
-      case ITypeSymbol { ContainingSymbol: INamespaceSymbol { IsGlobalNamespace: true } }:
-        builder.Append(symbol.MetadataName);
-        break;
-
-      // Types with a containing non-global namespace also append a leading '.'
-      case ITypeSymbol { ContainingSymbol: INamespaceSymbol namespaceSymbol }:
-        AppendFullyQualifiedMetadataName(namespaceSymbol, builder);
-        builder.Append('.');
-        builder.Append(symbol.MetadataName);
-        break;
-
-      // Nested types append a leading '+'
-      case ITypeSymbol { ContainingSymbol: ITypeSymbol typeSymbol }:
-        AppendFullyQualifiedMetadataName(typeSymbol, builder);
-        builder.Append('+');
-        builder.Append(symbol.MetadataName);
-        break;
-    }
-  }
-
-
   public static ImmutableArray<ISymbol> GetMembersIncludingBaseTypes(this ITypeSymbol symbol,
                                                                      Func<ISymbol, bool> predicate)
   {
@@ -65,6 +14,6 @@ public static ImmutableArray<ISymbol> GetMembersIncludingBaseTypes(this ITypeSym
     {
       members.AddRange(symbol.BaseType.GetMembersIncludingBaseTypes(predicate));
     }
-    return members.ToImmutableArray();
+    return [.. members];
   }
 }
diff --git a/Tum4ik.StinimGen/IIGenerator.cs b/Tum4ik.StinimGen/IIGenerator.cs
index 5d6bbe6..b47c98b 100644
--- a/Tum4ik.StinimGen/IIGenerator.cs
+++ b/Tum4ik.StinimGen/IIGenerator.cs
@@ -151,8 +151,8 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                   p => p.GetAttributes()
                     .Where(
                       a => a.AttributeClass?
-                        .GetFullyQualifiedMetadataName()?
-                        .StartsWith("System.Diagnostics.CodeAnalysis")
+                        .GetFullyQualifiedName()?
+                        .StartsWith("global::System.Diagnostics.CodeAnalysis")
                         is true
                     )
                     .Select(a => (AttributeListSyntax) syntaxGenerator.Attribute(a))
@@ -204,7 +204,7 @@ is true
           PropertyInfoList: propertyInfoList.ToImmutableArray(),
           EventInfoList: eventInfoList.ToImmutableArray(),
           MethodInfoList: methodInfoList.ToImmutableArray(),
-          SourceFullyQualifiedName: sourceNamedTypeSymbol.GetFullyQualifiedMetadataName(),
+          SourceFullyQualifiedName: sourceNamedTypeSymbol.GetFullyQualifiedName(),
           SourceForwardedAttributes: sourceForwardedAttributes
         );
       }