Fully qualify T.type_alias to ::T.type_alias

When erasing generic types we replace `type_member`s
with a `T.anything` type alias of the same name.
Qualifying `T.type_alias` to `::T.type_alias` ensures
we avoid conflicts like `T = T.type_alias`. This
matches

Author: dejmedus

lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs/base_translator.rb

@@ -270,7 +270,7 @@ def apply_class_annotations(node)
                   type_params.each do |type_param|
                     @rewriter << Source::Insert.new(
                       insert_pos,
-                      "\n#{indent}#{type_param.name} = T.type_alias { ::T.anything }\n",
+                      "\n#{indent}#{type_param.name} = ::T.type_alias { ::T.anything }\n",
                     )
                   end
 
@@ -417,7 +417,7 @@ def apply_type_aliases(comments)
               )
 
               @rewriter << Source::Delete.new(from, to)
-              content = "#{indent}#{alias_name} = T.type_alias { #{sorbet_type.to_rbi} }\n"
+              content = "#{indent}#{alias_name} = ::T.type_alias { #{sorbet_type.to_rbi} }\n"
               @rewriter << Source::Insert.new(insert_pos, content)
             rescue ::RBS::ParsingError, ::RBI::Error
               # Ignore type aliases with errors

test/spoom/cli/srb/sigs_test.rb

@@ -223,7 +223,7 @@ def push(value)
             # typed: true
 
             class Box
-              E = T.type_alias { ::T.anything }
+              E = ::T.type_alias { ::T.anything }
 
               sig { returns(Array) }
               def values

test/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs_test.rb

@@ -490,17 +490,17 @@ def parse_int(str)
 
           assert_equal(<<~RB, rbs_comments_to_sorbet_sigs(contents, erase_generic_types: true))
             class Result
-              T = T.type_alias { ::T.anything }
+              T = ::T.type_alias { ::T.anything }
 
-              A = T.type_alias { ::T.anything }
+              A = ::T.type_alias { ::T.anything }
 
-              B = T.type_alias { ::T.anything }
+              B = ::T.type_alias { ::T.anything }
 
-              C = T.type_alias { ::T.anything }
+              C = ::T.type_alias { ::T.anything }
 
-              D = T.type_alias { ::T.anything }
+              D = ::T.type_alias { ::T.anything }
 
-              E = T.type_alias { ::T.anything }
+              E = ::T.type_alias { ::T.anything }
 
               sig { params(value: T, error: ::T.nilable(E)).void }
               def initialize(value, error)
@@ -560,7 +560,7 @@ def wrap(value)
               end
 
               class << self
-                V = T.type_alias { ::T.anything }
+                V = ::T.type_alias { ::T.anything }
 
                 sig { returns(V) }
                 def build; end
@@ -687,8 +687,8 @@ def bar(a)
 
             to_pretty_format_for_humans: <<~RUBY,
               module Aliases
-                Foo = T.type_alias { ::T.any(Integer, String) }
-                MultiLine = T.type_alias { ::T.any(Integer, String) }
+                Foo = ::T.type_alias { ::T.any(Integer, String) }
+                MultiLine = ::T.type_alias { ::T.any(Integer, String) }
               end
 
               sig { params(a: Aliases::Foo).returns(Aliases::MultiLine) }
@@ -712,8 +712,8 @@ def process_user(data)
             RUBY
 
             to_pretty_format_for_humans: <<~RUBY,
-              Foo::UserId = T.type_alias { Integer }
-              ::Bar::UserData = T.type_alias { { id: Foo::UserId, name: String } }
+              Foo::UserId = ::T.type_alias { Integer }
+              ::Bar::UserData = ::T.type_alias { { id: Foo::UserId, name: String } }
 
               sig { params(data: ::Bar::UserData).returns(Foo::UserId) }
               def process_user(data)
@@ -738,7 +738,7 @@ def get_status
 
             to_pretty_format_for_humans: <<~RUBY,
               class Example
-                Status = T.type_alias { Symbol }
+                Status = ::T.type_alias { Symbol }
 
                 sig { returns(Status) }
                 def get_status
@@ -761,7 +761,7 @@ def status; end
 
             to_pretty_format_for_humans: <<~RUBY,
               class Example
-                Status = T.type_alias { Symbol }
+                Status = ::T.type_alias { Symbol }
                 sig { returns(Status) }
                 def status; end
               end
@@ -783,7 +783,7 @@ def double_items(items)
             RUBY
 
             to_pretty_format_for_humans: <<~RUBY,
-              List = T.type_alias { ::T::Array[Integer] }
+              List = ::T.type_alias { ::T::Array[Integer] }
 
               sig { params(items: List).returns(List) }
               def double_items(items)
@@ -808,7 +808,7 @@ def build_box
           assert_equal(<<~RB, rbs_comments_to_sorbet_sigs(contents, erase_generic_types: true))
             class Box; end
 
-            BoxedString = T.type_alias { Box }
+            BoxedString = ::T.type_alias { Box }
 
             sig { returns(BoxedString) }
             def build_box
@@ -829,7 +829,7 @@ def ensure_string(text)
             RUBY
 
             to_pretty_format_for_humans: <<~RUBY,
-              NullableString = T.type_alias { ::T.nilable(String) }
+              NullableString = ::T.type_alias { ::T.nilable(String) }
 
               sig { params(text: NullableString).returns(String) }
               def ensure_string(text)
@@ -871,7 +871,7 @@ def foo
             RUBY
 
             to_pretty_format_for_humans: <<~RUBY,
-              MultiLine = T.type_alias { ::T.any(String, Integer) }
+              MultiLine = ::T.type_alias { ::T.any(String, Integer) }
               # foo bar baz
               #| | Symbol
 
@@ -908,7 +908,7 @@ class Range
 
             to_pretty_format_for_humans: <<~RUBY,
               module Foo
-                SerializedRange = T.type_alias { [Integer, Integer] }
+                SerializedRange = ::T.type_alias { [Integer, Integer] }
                 class Range
                 end
               end