rbi 0.3.6 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80df141e229452edf3fb51dc8933c130ce2a2f972ee6906be79680d79f33a720
-  data.tar.gz: '099a5b5fb43ccd50cf262bcdbc0d8fde6cd0aa14983851c9de14f488def2a56b'
+  metadata.gz: e8a26f05eff609245be847ff291cfd456b86e0a11aa85c496bcdcbaf8c202b5b
+  data.tar.gz: f1eb34ff26a99f6b1b20edfaec281db99559cce730e3c0cdbf0d8c75a8e6ee91
 SHA512:
-  metadata.gz: 791d993759d3e237a52d34be622c23eec92d1adb26b267aa47b3aa9e7ce1767b96fff75e02d895493fb63b84fe3f15cb1c37f880db1698e5a8b9e17cba77503e
-  data.tar.gz: cdf11ef801d7ac8a1329b39e095c4895d006ae46ad800d50d1d2cb52aa9c41fdb704557a8a660376b53e4bdb86a076bacde0a5a2c33d0031478dda36850297b1
+  metadata.gz: 9cbe3f72073f2813cef4744b57849d8725eab8ed19df9b14d7d7571f795dd90ca925645eed50f62ff86d8a387a5e845a516a7dfc097593788e9b27c6d6489edd
+  data.tar.gz: 72e11ed844915a8965f3a0db4f76b7cb3b6e22e6eb7848bcf2f5484a415bdf79fd7c552c811b279cb006121179c8ebc1cfa58bcbe3d95e2089fec02f1f8ab8a0

data/Gemfile

@@ -10,10 +10,10 @@ group(:development, :test) do
   gem("minitest")
   gem("minitest-reporters")
   gem("rake", "~> 13.3")
-  gem("rubocop", "~> 1.76", require: false)
+  gem("rubocop", "~> 1.81", require: false)
   gem("rubocop-shopify", require: false)
   gem("rubocop-sorbet", require: false)
   gem("sorbet", ">= 0.5.9204", require: false)
-  gem("spoom", ">= 1.6.0", require: false)
-  gem("tapioca", require: false)
+  gem("spoom", ">= 1.7.10", require: false)
+  gem("tapioca", ">= 0.17.9", require: false)
 end

data/lib/rbi/formatter.rb

@@ -6,7 +6,15 @@ module RBI
     #: Integer?
     attr_accessor :max_line_length
 
-    #: (?add_sig_templates: bool, ?group_nodes: bool, ?max_line_length: Integer?, ?nest_singleton_methods: bool, ?nest_non_public_members: bool, ?sort_nodes: bool, ?replace_attributes_with_methods: bool) -> void
+    #: (
+    #|   ?add_sig_templates: bool,
+    #|   ?group_nodes: bool,
+    #|   ?max_line_length: Integer?,
+    #|   ?nest_singleton_methods: bool,
+    #|   ?nest_non_public_members: bool,
+    #|   ?sort_nodes: bool,
+    #|   ?replace_attributes_with_methods: bool
+    #| ) -> void
     def initialize(
       add_sig_templates: false,
       group_nodes: false,

data/lib/rbi/index.rb

@@ -73,7 +73,7 @@ module RBI
     # getter and the setter.
     # @abstract
     #: -> Array[String]
-    def index_ids; end
+    def index_ids = raise NotImplementedError, "Abstract method called"
   end
 
   class Scope

data/lib/rbi/loc.rb

@@ -22,7 +22,13 @@ module RBI
     #: Integer?
     attr_reader :begin_line, :end_line, :begin_column, :end_column
 
-    #: (?file: String?, ?begin_line: Integer?, ?end_line: Integer?, ?begin_column: Integer?, ?end_column: Integer?) -> void
+    #: (
+    #|   ?file: String?,
+    #|   ?begin_line: Integer?,
+    #|   ?end_line: Integer?,
+    #|   ?begin_column: Integer?,
+    #|   ?end_column: Integer?
+    #| ) -> void
     def initialize(file: nil, begin_line: nil, end_line: nil, begin_column: nil, end_column: nil)
       @file = file
       @begin_line = begin_line

data/lib/rbi/model.rb

@@ -163,7 +163,7 @@ module RBI
   class Scope < Tree
     # @abstract
     #: -> String
-    def fully_qualified_name; end
+    def fully_qualified_name = raise NotImplementedError, "Abstract method called"
 
     # @override
     #: -> String
@@ -240,7 +240,13 @@ module RBI
     #: bool
     attr_accessor :keyword_init
 
-    #: (String name, ?members: Array[Symbol], ?keyword_init: bool, ?loc: Loc?, ?comments: Array[Comment]) ?{ (Struct struct) -> void } -> void
+    #: (
+    #|   String name,
+    #|   ?members: Array[Symbol],
+    #|   ?keyword_init: bool,
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) ?{ (Struct struct) -> void } -> void
     def initialize(name, members: [], keyword_init: false, loc: nil, comments: [], &block)
       super(loc: loc, comments: comments) {}
       @name = name
@@ -299,7 +305,14 @@ module RBI
     #: Array[Sig]
     attr_reader :sigs
 
-    #: (Symbol name, Array[Symbol] names, ?visibility: Visibility, ?sigs: Array[Sig], ?loc: Loc?, ?comments: Array[Comment]) -> void
+    #: (
+    #|   Symbol name,
+    #|   Array[Symbol] names,
+    #|   ?visibility: Visibility,
+    #|   ?sigs: Array[Sig],
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) -> void
     def initialize(name, names, visibility: Public.new, sigs: [], loc: nil, comments: [])
       super(loc: loc, comments: comments)
       @names = [name, *names] #: Array[Symbol]
@@ -309,11 +322,18 @@ module RBI
 
     # @abstract
     #: -> Array[String]
-    def fully_qualified_names; end
+    def fully_qualified_names = raise NotImplementedError, "Abstract method called"
   end
 
   class AttrAccessor < Attr
-    #: (Symbol name, *Symbol names, ?visibility: Visibility, ?sigs: Array[Sig], ?loc: Loc?, ?comments: Array[Comment]) ?{ (AttrAccessor node) -> void } -> void
+    #: (
+    #|   Symbol name,
+    #|   *Symbol names,
+    #|   ?visibility: Visibility,
+    #|   ?sigs: Array[Sig],
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) ?{ (AttrAccessor node) -> void } -> void
     def initialize(name, *names, visibility: Public.new, sigs: [], loc: nil, comments: [], &block)
       super(name, names, loc: loc, visibility: visibility, sigs: sigs, comments: comments)
       block&.call(self)
@@ -335,7 +355,14 @@ module RBI
   end
 
   class AttrReader < Attr
-    #: (Symbol name, *Symbol names, ?visibility: Visibility, ?sigs: Array[Sig], ?loc: Loc?, ?comments: Array[Comment]) ?{ (AttrReader node) -> void } -> void
+    #: (
+    #|   Symbol name,
+    #|   *Symbol names,
+    #|   ?visibility: Visibility,
+    #|   ?sigs: Array[Sig],
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) ?{ (AttrReader node) -> void } -> void
     def initialize(name, *names, visibility: Public.new, sigs: [], loc: nil, comments: [], &block)
       super(name, names, loc: loc, visibility: visibility, sigs: sigs, comments: comments)
       block&.call(self)
@@ -357,7 +384,14 @@ module RBI
   end
 
   class AttrWriter < Attr
-    #: (Symbol name, *Symbol names, ?visibility: Visibility, ?sigs: Array[Sig], ?loc: Loc?, ?comments: Array[Comment]) ?{ (AttrWriter node) -> void } -> void
+    #: (
+    #|   Symbol name,
+    #|   *Symbol names,
+    #|   ?visibility: Visibility,
+    #|   ?sigs: Array[Sig],
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) ?{ (AttrWriter node) -> void } -> void
     def initialize(name, *names, visibility: Public.new, sigs: [], loc: nil, comments: [], &block)
       super(name, names, loc: loc, visibility: visibility, sigs: sigs, comments: comments)
       block&.call(self)
@@ -396,7 +430,15 @@ module RBI
     #: Array[Sig]
     attr_accessor :sigs
 
-    #: (String name, ?params: Array[Param], ?is_singleton: bool, ?visibility: Visibility, ?sigs: Array[Sig], ?loc: Loc?, ?comments: Array[Comment]) ?{ (Method node) -> void } -> void
+    #: (
+    #|   String name,
+    #|   ?params: Array[Param],
+    #|   ?is_singleton: bool,
+    #|   ?visibility: Visibility,
+    #|   ?sigs: Array[Sig],
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) ?{ (Method node) -> void } -> void
     def initialize(
       name,
       params: [],
@@ -456,7 +498,15 @@ module RBI
       @params << BlockParam.new(name)
     end
 
-    #: (?params: Array[SigParam], ?return_type: (String | Type), ?is_abstract: bool, ?is_override: bool, ?is_overridable: bool, ?is_final: bool, ?type_params: Array[String], ?checked: Symbol?) ?{ (Sig node) -> void } -> void
+    #: (
+    #|   ?params: Array[SigParam],
+    #|   ?return_type: (String | Type),
+    #|   ?is_abstract: bool,
+    #|   ?is_override: bool,
+    #|   ?is_overridable: bool,
+    #|   ?is_final: bool,
+    #|   ?type_params: Array[String],
+    #|   ?checked: Symbol?) ?{ (Sig node) -> void } -> void
     def add_sig(
       params: [],
       return_type: "void",
@@ -832,7 +882,25 @@ module RBI
     attr_accessor :return_type
 
     #: bool
-    attr_accessor :is_abstract, :is_override, :is_overridable, :is_final, :allow_incompatible_override, :without_runtime
+    attr_accessor :is_abstract
+
+    #: bool
+    attr_accessor :is_override
+
+    #: bool
+    attr_accessor :is_overridable
+
+    #: bool
+    attr_accessor :is_final
+
+    #: bool
+    attr_accessor :allow_incompatible_override
+
+    #: bool
+    attr_accessor :allow_incompatible_override_visibility
+
+    #: bool
+    attr_accessor :without_runtime
 
     #: Array[String]
     attr_reader :type_params
@@ -840,7 +908,21 @@ module RBI
     #: Symbol?
     attr_accessor :checked
 
-    #: (?params: Array[SigParam], ?return_type: (Type | String), ?is_abstract: bool, ?is_override: bool, ?is_overridable: bool, ?is_final: bool, ?allow_incompatible_override: bool, ?without_runtime: bool, ?type_params: Array[String], ?checked: Symbol?, ?loc: Loc?, ?comments: Array[Comment]) ?{ (Sig node) -> void } -> void
+    #: (
+    #|   ?params: Array[SigParam],
+    #|   ?return_type: (Type | String),
+    #|   ?is_abstract: bool,
+    #|   ?is_override: bool,
+    #|   ?is_overridable: bool,
+    #|   ?is_final: bool,
+    #|   ?allow_incompatible_override: bool,
+    #|   ?allow_incompatible_override_visibility: bool,
+    #|   ?without_runtime: bool,
+    #|   ?type_params: Array[String],
+    #|   ?checked: Symbol?,
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) ?{ (Sig node) -> void } -> void
     def initialize(
       params: [],
       return_type: "void",
@@ -849,6 +931,7 @@ module RBI
       is_overridable: false,
       is_final: false,
       allow_incompatible_override: false,
+      allow_incompatible_override_visibility: false,
       without_runtime: false,
       type_params: [],
       checked: nil,
@@ -864,6 +947,7 @@ module RBI
       @is_overridable = is_overridable
       @is_final = is_final
       @allow_incompatible_override = allow_incompatible_override
+      @allow_incompatible_override_visibility = allow_incompatible_override_visibility
       @without_runtime = without_runtime
       @type_params = type_params
       @checked = checked
@@ -942,11 +1026,17 @@ module RBI
 
     # @abstract
     #: -> Array[String]
-    def fully_qualified_names; end
+    def fully_qualified_names = raise NotImplementedError, "Abstract method called"
   end
 
   class TStructConst < TStructField
-    #: (String name, (Type | String) type, ?default: String?, ?loc: Loc?, ?comments: Array[Comment]) ?{ (TStructConst node) -> void } -> void
+    #: (
+    #|   String name,
+    #|   (Type | String) type,
+    #|   ?default: String?,
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) ?{ (TStructConst node) -> void } -> void
     def initialize(name, type, default: nil, loc: nil, comments: [], &block)
       super(name, type, default: default, loc: loc, comments: comments)
       block&.call(self)
@@ -967,7 +1057,13 @@ module RBI
   end
 
   class TStructProp < TStructField
-    #: (String name, (Type | String) type, ?default: String?, ?loc: Loc?, ?comments: Array[Comment]) ?{ (TStructProp node) -> void } -> void
+    #: (
+    #|   String name,
+    #|   (Type | String) type,
+    #|   ?default: String?,
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) ?{ (TStructProp node) -> void } -> void
     def initialize(name, type, default: nil, loc: nil, comments: [], &block)
       super(name, type, default: default, loc: loc, comments: comments)
       block&.call(self)
@@ -1087,7 +1183,12 @@ module RBI
   end
 
   class MixesInClassMethods < Mixin
-    #: (String name, *String names, ?loc: Loc?, ?comments: Array[Comment]) ?{ (MixesInClassMethods node) -> void } -> void
+    #: (
+    #|   String name,
+    #|   *String names,
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment]
+    #| ) ?{ (MixesInClassMethods node) -> void } -> void
     def initialize(name, *names, loc: nil, comments: [], &block)
       super(name, names, loc: loc, comments: comments)
       block&.call(self)

data/lib/rbi/parser.rb

@@ -946,22 +946,8 @@ module RBI
           end
         when "override"
           @current.is_override = true
-
-          args = node.arguments&.arguments
-
-          keywords_hash = args
-            &.grep(Prism::KeywordHashNode)
-            &.first
-
-          allow_incompatible_override = keywords_hash
-            &.elements
-            &.any? do |assoc|
-              assoc.is_a?(Prism::AssocNode) &&
-                node_string(assoc.key) == "allow_incompatible:" &&
-                node_string(assoc.value) == "true"
-            end
-
-          @current.allow_incompatible_override = !!allow_incompatible_override
+          @current.allow_incompatible_override = allow_incompatible_override?(node, "true")
+          @current.allow_incompatible_override_visibility = allow_incompatible_override?(node, ":visibility")
         when "overridable"
           @current.is_overridable = true
         when "params"
@@ -995,6 +981,23 @@ module RBI
           node_string!(node.value),
         )
       end
+
+      #: (Prism::CallNode node, String value) -> bool
+      def allow_incompatible_override?(node, value)
+        args = node.arguments&.arguments
+
+        keywords_hash = args
+          &.grep(Prism::KeywordHashNode)
+          &.first
+
+        !!keywords_hash
+          &.elements
+          &.any? do |assoc|
+            assoc.is_a?(Prism::AssocNode) &&
+              node_string(assoc.key) == "allow_incompatible:" &&
+              node_string(assoc.value) == value
+          end
+      end
     end
 
     class HeredocLocationVisitor < Prism::Visitor

data/lib/rbi/printer.rb

@@ -800,6 +800,8 @@ module RBI
       if node.is_override
         modifiers << if node.allow_incompatible_override
           "override(allow_incompatible: true)"
+        elsif node.allow_incompatible_override_visibility
+          "override(allow_incompatible: :visibility)"
         else
           "override"
         end

data/lib/rbi/rbs/type_translator.rb

@@ -33,8 +33,7 @@ module RBI
         def translate(type)
           case type
           when ::RBS::Types::Alias
-            # TODO: unsupported yet
-            Type.untyped
+            translate_type_alias(type)
           when ::RBS::Types::Bases::Any
             Type.untyped
           when ::RBS::Types::Bases::Bool
@@ -85,12 +84,24 @@ module RBI
           when ::RBS::Types::Variable
             Type.type_parameter(type.name)
           else
-            T.absurd(type)
+            type #: absurd
           end
         end
 
         private
 
+        #: (::RBS::Types::Alias) -> Type
+        def translate_type_alias(type)
+          name = ::RBS::TypeName.new(
+            namespace: type.name.namespace,
+            name: type.name.name.to_s.gsub(/(?:^|_)([a-z\d]*)/i) do |match|
+              match = match.delete_prefix("_")
+              !match.empty? ? match[0].upcase.concat(match[1..-1]) : +""
+            end,
+          )
+          Type.simple(name.to_s)
+        end
+
         #: (::RBS::Types::ClassInstance) -> Type
         def translate_class_instance(type)
           return Type.simple(type.name.to_s) if type.args.empty?
@@ -150,23 +161,25 @@ module RBI
         def translate_t_generic_type(type_name)
           case type_name.delete_prefix("::")
           when "Array"
-            "T::Array"
+            "::T::Array"
           when "Class"
-            "T::Class"
+            "::T::Class"
           when "Enumerable"
-            "T::Enumerable"
+            "::T::Enumerable"
           when "Enumerator"
-            "T::Enumerator"
+            "::T::Enumerator"
           when "Enumerator::Chain"
-            "T::Enumerator::Chain"
+            "::T::Enumerator::Chain"
           when "Enumerator::Lazy"
-            "T::Enumerator::Lazy"
+            "::T::Enumerator::Lazy"
           when "Hash"
-            "T::Hash"
+            "::T::Hash"
+          when "Module"
+            "::T::Module"
           when "Set"
-            "T::Set"
+            "::T::Set"
           when "Range"
-            "T::Range"
+            "::T::Range"
           else
             type_name
           end

data/lib/rbi/rbs_printer.rb

@@ -337,6 +337,8 @@ module RBI
       if node.sigs.any?(&:is_override)
         if node.sigs.any?(&:allow_incompatible_override)
           printl("# @override(allow_incompatible: true)")
+        elsif node.sigs.any?(&:allow_incompatible_override_visibility)
+          printl("# @override(allow_incompatible: :visibility)")
         else
           printl("# @override")
         end
@@ -1028,6 +1030,8 @@ module RBI
         visit_type_parameter(node)
       when Type::Class
         visit_class(node)
+      when Type::Module
+        visit_module(node)
       else
         raise Error, "Unhandled node: #{node.class}"
       end
@@ -1188,6 +1192,13 @@ module RBI
       @string << "]"
     end
 
+    #: (Type::Module type) -> void
+    def visit_module(type)
+      @string << "Module["
+      visit(type.type)
+      @string << "]"
+    end
+
     private
 
     #: (String type_name) -> String
@@ -1195,10 +1206,20 @@ module RBI
       case type_name
       when "T::Array"
         "Array"
+      when "T::Enumerable"
+        "Enumerable"
+      when "T::Enumerator"
+        "Enumerator"
+      when "T::Enumerator::Chain"
+        "Enumerator::Chain"
+      when "T::Enumerator::Lazy"
+        "Enumerator::Lazy"
       when "T::Hash"
         "Hash"
       when "T::Set"
         "Set"
+      when "T::Range"
+        "Range"
       else
         type_name
       end

data/lib/rbi/rewriters/attr_to_methods.rb

@@ -56,7 +56,7 @@ module RBI
   class Attr
     # @abstract
     #: -> Array[Method]
-    def convert_to_methods; end
+    def convert_to_methods = raise NotImplementedError, "Abstract method called"
 
     private
 
@@ -88,7 +88,14 @@ module RBI
       )
     end
 
-    #: (String name, Sig? sig, (Type | String)? attribute_type, Visibility visibility, Loc? loc, Array[Comment] comments) -> Method
+    #: (
+    #|   String name,
+    #|   Sig? sig,
+    #|   (Type | String)? attribute_type,
+    #|   Visibility visibility,
+    #|   Loc? loc,
+    #|   Array[Comment] comments
+    #| ) -> Method
     def create_setter_method(name, sig, attribute_type, visibility, loc, comments) # rubocop:disable Metrics/ParameterLists
       sig = if sig # Modify the original sig to correct the name, and remove the return type
         params = attribute_type ? [SigParam.new(name, attribute_type)] : []

data/lib/rbi/rewriters/merge_trees.rb

@@ -330,7 +330,11 @@ module RBI
     #: Array[Rewriters::Merge::Conflict]
     attr_reader :conflicts
 
-    #: (?loc: Loc?, ?comments: Array[Comment], ?conflicts: Array[Rewriters::Merge::Conflict]) ?{ (Tree node) -> void } -> void
+    #: (
+    #|   ?loc: Loc?,
+    #|   ?comments: Array[Comment],
+    #|   ?conflicts: Array[Rewriters::Merge::Conflict]
+    #| ) ?{ (Tree node) -> void } -> void
     def initialize(loc: nil, comments: [], conflicts: [], &block)
       super(loc: loc, comments: comments)
       @conflicts = conflicts

data/lib/rbi/type.rb

@@ -58,7 +58,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T.anything"
+        "::T.anything"
       end
 
       # @override
@@ -85,7 +85,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T.attached_class"
+        "::T.attached_class"
       end
 
       # @override
@@ -139,7 +139,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T.noreturn"
+        "::T.noreturn"
       end
 
       # @override
@@ -166,7 +166,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T.self_type"
+        "::T.self_type"
       end
 
       # @override
@@ -193,7 +193,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T.untyped"
+        "::T.untyped"
       end
 
       # @override
@@ -274,6 +274,42 @@ module RBI
       end
     end
 
+    # The module of another type like `T::Module[Foo]`.
+    class Module < Type
+      #: Type
+      attr_reader :type
+
+      #: (Type type) -> void
+      def initialize(type)
+        super()
+        @type = type
+      end
+
+      # @override
+      #: (BasicObject other) -> bool
+      def ==(other)
+        Module === other && @type == other.type
+      end
+
+      # @override
+      #: -> String
+      def to_rbi
+        "T::Module[#{@type}]"
+      end
+
+      # @override
+      #: -> Type
+      def normalize
+        self
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        self
+      end
+    end
+
     # The singleton class of another type like `T.class_of(Foo)`.
     class ClassOf < Type
       #: Simple
@@ -299,9 +335,9 @@ module RBI
       #: -> String
       def to_rbi
         if @type_parameter
-          "T.class_of(#{@type.to_rbi})[#{@type_parameter.to_rbi}]"
+          "::T.class_of(#{@type.to_rbi})[#{@type_parameter.to_rbi}]"
         else
-          "T.class_of(#{@type.to_rbi})"
+          "::T.class_of(#{@type.to_rbi})"
         end
       end
 
@@ -338,7 +374,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T.nilable(#{@type.to_rbi})"
+        "::T.nilable(#{@type.to_rbi})"
       end
 
       # @override
@@ -385,7 +421,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T.all(#{@types.map(&:to_rbi).join(", ")})"
+        "::T.all(#{@types.map(&:to_rbi).join(", ")})"
       end
 
       # @override
@@ -427,7 +463,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T.any(#{@types.map(&:to_rbi).join(", ")})"
+        "::T.any(#{@types.map(&:to_rbi).join(", ")})"
       end
 
       #: -> bool
@@ -567,7 +603,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T.type_parameter(#{@name.inspect})"
+        "::T.type_parameter(#{@name.inspect})"
       end
 
       # @override
@@ -583,6 +619,46 @@ module RBI
       end
     end
 
+    # A type alias that references another type by name like `MyTypeAlias`.
+    class TypeAlias < Type
+      #: String
+      attr_reader :name
+
+      #: Type
+      attr_reader :aliased_type
+
+      #: (String name, Type aliased_type) -> void
+      def initialize(name, aliased_type)
+        super()
+        @name = name
+        @aliased_type = aliased_type
+      end
+
+      # @override
+      #: (BasicObject other) -> bool
+      def ==(other)
+        TypeAlias === other && @name == other.name && @aliased_type == other.aliased_type
+      end
+
+      # @override
+      #: -> String
+      def to_rbi
+        "#{name} = ::T.type_alias { #{aliased_type.to_rbi} }"
+      end
+
+      # @override
+      #: -> Type
+      def normalize
+        TypeAlias.new(name, aliased_type.normalize)
+      end
+
+      # @override
+      #: -> Type
+      def simplify
+        TypeAlias.new(name, aliased_type.simplify)
+      end
+    end
+
     # Tuples and shapes
 
     # A tuple type like `[String, Integer]`.
@@ -720,7 +796,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        rbi = +"T.proc"
+        rbi = +"::T.proc"
 
         if @proc_bind
           rbi << ".bind(#{@proc_bind})"
@@ -823,6 +899,12 @@ module RBI
         Class.new(type)
       end
 
+      # Builds a type that represents the module of another type like `T::Module[Foo]`.
+      #: (Type type) -> Module
+      def t_module(type)
+        Module.new(type)
+      end
+
       # Builds a type that represents the singleton class of another type like `T.class_of(Foo)`.
       #: (Simple type, ?Type? type_parameter) -> ClassOf
       def class_of(type, type_parameter = nil)
@@ -871,6 +953,12 @@ module RBI
         TypeParameter.new(name)
       end
 
+      # Builds a type that represents a type alias like `MyTypeAlias`.
+      #: (String name, Type aliased_type) -> TypeAlias
+      def type_alias(name, aliased_type)
+        TypeAlias.new(name, aliased_type)
+      end
+
       # Tuples and shapes
 
       # Builds a type that represents a tuple type like `[String, Integer]`.
@@ -912,8 +1000,8 @@ module RBI
     # ```ruby
     # type = RBI::Type.simple("String")
     # type.to_rbi # => "String"
-    # type.nilable.to_rbi # => "T.nilable(String)"
-    # type.nilable.nilable.to_rbi # => "T.nilable(String)"
+    # type.nilable.to_rbi # => "::T.nilable(String)"
+    # type.nilable.nilable.to_rbi # => "::T.nilable(String)"
     # ```
     #: -> Type
     def nilable
@@ -926,7 +1014,7 @@ module RBI
     #
     # ```ruby
     # type = RBI::Type.nilable(RBI::Type.simple("String"))
-    # type.to_rbi # => "T.nilable(String)"
+    # type.to_rbi # => "::T.nilable(String)"
     # type.non_nilable.to_rbi # => "String"
     # type.non_nilable.non_nilable.to_rbi # => "String"
     # ```
@@ -957,7 +1045,7 @@ module RBI
     #
     # @abstract
     #: -> Type
-    def normalize; end
+    def normalize = raise NotImplementedError, "Abstract method called"
 
     # Returns a simplified version of the type.
     #
@@ -969,11 +1057,11 @@ module RBI
     #
     # @abstract
     #: -> Type
-    def simplify; end
+    def simplify = raise NotImplementedError, "Abstract method called"
 
     # @abstract
     #: (BasicObject) -> bool
-    def ==(other); end
+    def ==(other) = raise NotImplementedError, "Abstract method called"
 
     #: (BasicObject other) -> bool
     def eql?(other)
@@ -988,7 +1076,7 @@ module RBI
 
     # @abstract
     #: -> String
-    def to_rbi; end
+    def to_rbi = raise NotImplementedError, "Abstract method called"
 
     # @override
     #: -> String

data/lib/rbi/type_parser.rb

@@ -27,6 +27,8 @@ module RBI
         case node
         when Prism::ConstantReadNode, Prism::ConstantPathNode
           parse_constant(node)
+        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+          parse_constant_assignment(node)
         when Prism::CallNode
           parse_call(node)
         when Prism::ArrayNode
@@ -67,6 +69,29 @@ module RBI
         end
       end
 
+      #: (Prism::ConstantWriteNode | Prism::ConstantPathWriteNode node) -> Type
+      def parse_constant_assignment(node)
+        if t_type_alias?(node.value)
+          value = node.value #: as Prism::CallNode
+          name = if node.is_a?(Prism::ConstantPathWriteNode)
+            node.target.full_name
+          else
+            node.full_name
+          end
+
+          body = value.block
+
+          if body.is_a?(Prism::BlockNode) && (stmts = body.body).is_a?(Prism::StatementsNode)
+            body_node = stmts.body.first #: as !nil
+            Type::TypeAlias.new(name, parse_node(body_node))
+          else
+            Type::Simple.new(node.slice)
+          end
+        else
+          Type::Simple.new(node.slice)
+        end
+      end
+
       #: (Prism::CallNode node) -> Type
       def parse_call(node)
         recv = node.receiver
@@ -91,6 +116,14 @@ module RBI
                   args.first, #: as !nil
                 ),
               )
+            elsif t_module?(recv)
+              # `T::Module[Foo]` or `::T::Module[Foo]`
+              args = check_arguments_exactly!(node, 1)
+              return Type::Module.new(
+                parse_node(
+                  args.first, #: as !nil
+                ),
+              )
             else
               # `::Foo[Bar]` or `::Foo[Bar, Baz]`
               args = check_arguments_at_least!(node, 1)
@@ -310,6 +343,13 @@ module RBI
         false
       end
 
+      #: (Prism::Node? node) -> bool
+      def t_type_alias?(node)
+        return false unless node.is_a?(Prism::CallNode)
+
+        t?(node.receiver) && node.name == :type_alias
+      end
+
       #: (Prism::Node? node) -> bool
       def t_boolean?(node)
         return false unless node.is_a?(Prism::ConstantPathNode)
@@ -322,6 +362,11 @@ module RBI
         t?(node.parent) && node.name == :Class
       end
 
+      #: (Prism::ConstantPathNode node) -> bool
+      def t_module?(node)
+        t?(node.parent) && node.name == :Module
+      end
+
       #: (Prism::Node? node) -> bool
       def t_class_of?(node)
         return false unless node.is_a?(Prism::CallNode)

data/lib/rbi/type_visitor.rb

@@ -45,6 +45,8 @@ module RBI
           visit_type_parameter(node)
         when Type::Class
           visit_class(node)
+        when Type::TypeAlias
+          visit_type_alias(node)
         else
           raise Error, "Unhandled node: #{node.class}"
         end
@@ -105,6 +107,9 @@ module RBI
 
       #: (Type::Untyped type) -> void
       def visit_untyped(type); end
+
+      #: (Type::TypeAlias type) -> void
+      def visit_type_alias(type); end
     end
   end
 end

data/lib/rbi/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module RBI
-  VERSION = "0.3.6"
+  VERSION = "0.3.8"
 end

data/rbi/rbi.rbi

@@ -2,7 +2,7 @@
 
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rbi` gem.
-# Please instead update this file by running `spoom srb sigs export`.
+# Please instead update this file by running `bundle exec spoom srb sigs export`.
 
 module RBI; end
 
@@ -968,6 +968,9 @@ class RBI::Parser::SigBuilder < ::RBI::Parser::Visitor
   sig { params(content: ::String, file: ::String).void }
   def initialize(content, file:); end
 
+  sig { params(node: ::Prism::CallNode, value: ::String).returns(T::Boolean) }
+  def allow_incompatible_override?(node, value); end
+
   sig { returns(::RBI::Sig) }
   def current; end
 
@@ -1418,6 +1421,9 @@ class RBI::RBS::TypeTranslator
 
     sig { params(type_name: ::String).returns(::String) }
     def translate_t_generic_type(type_name); end
+
+    sig { params(type: ::RBS::Types::Alias).returns(::RBI::Type) }
+    def translate_type_alias(type); end
   end
 end
 
@@ -2102,6 +2108,7 @@ class RBI::Sig < ::RBI::NodeWithComments
       is_overridable: T::Boolean,
       is_final: T::Boolean,
       allow_incompatible_override: T::Boolean,
+      allow_incompatible_override_visibility: T::Boolean,
       without_runtime: T::Boolean,
       type_params: T::Array[::String],
       checked: T.nilable(::Symbol),
@@ -2110,7 +2117,7 @@ class RBI::Sig < ::RBI::NodeWithComments
       block: T.nilable(T.proc.params(node: ::RBI::Sig).void)
     ).void
   end
-  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), allow_incompatible_override: T.unsafe(nil), without_runtime: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), allow_incompatible_override: T.unsafe(nil), allow_incompatible_override_visibility: T.unsafe(nil), without_runtime: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
   sig { params(param: ::RBI::SigParam).void }
   def <<(param); end
@@ -2121,9 +2128,16 @@ class RBI::Sig < ::RBI::NodeWithComments
   sig { params(name: ::String, type: T.any(::RBI::Type, ::String)).void }
   def add_param(name, type); end
 
+  sig { returns(T::Boolean) }
   def allow_incompatible_override; end
+
   def allow_incompatible_override=(_arg0); end
 
+  sig { returns(T::Boolean) }
+  def allow_incompatible_override_visibility; end
+
+  def allow_incompatible_override_visibility=(_arg0); end
+
   sig { returns(T.nilable(::Symbol)) }
   def checked; end
 
@@ -2133,11 +2147,20 @@ class RBI::Sig < ::RBI::NodeWithComments
   def is_abstract; end
 
   def is_abstract=(_arg0); end
+
+  sig { returns(T::Boolean) }
   def is_final; end
+
   def is_final=(_arg0); end
+
+  sig { returns(T::Boolean) }
   def is_overridable; end
+
   def is_overridable=(_arg0); end
+
+  sig { returns(T::Boolean) }
   def is_override; end
+
   def is_override=(_arg0); end
 
   sig { returns(T::Array[::RBI::SigParam]) }
@@ -2151,7 +2174,9 @@ class RBI::Sig < ::RBI::NodeWithComments
   sig { returns(T::Array[::String]) }
   def type_params; end
 
+  sig { returns(T::Boolean) }
   def without_runtime; end
+
   def without_runtime=(_arg0); end
 end
 
@@ -2407,58 +2432,6 @@ class RBI::Tree < ::RBI::NodeWithComments
   sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
   def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
 
-  sig do
-    params(
-      name: ::String,
-      superclass_name: T.nilable(::String),
-      block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
-    ).returns(::RBI::Scope)
-  end
-  def create_class(name, superclass_name: T.unsafe(nil), &block); end
-
-  sig { params(name: ::String, value: ::String).void }
-  def create_constant(name, value:); end
-
-  sig { params(name: ::String).void }
-  def create_extend(name); end
-
-  sig { params(name: ::String).void }
-  def create_include(name); end
-
-  sig do
-    params(
-      name: ::String,
-      parameters: T::Array[::RBI::TypedParam],
-      return_type: T.nilable(::String),
-      class_method: T::Boolean,
-      visibility: ::RBI::Visibility,
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Method).void)
-    ).void
-  end
-  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(name: ::String).void }
-  def create_mixes_in_class_methods(name); end
-
-  sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
-  def create_module(name, &block); end
-
-  sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
-  def create_path(constant, &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: ::String,
-      variance: ::Symbol,
-      fixed: T.nilable(::String),
-      upper: T.nilable(::String),
-      lower: T.nilable(::String)
-    ).void
-  end
-  def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
-
   sig { params(annotation: ::String).void }
   def deannotate!(annotation); end
 
@@ -2510,14 +2483,6 @@ class RBI::Tree < ::RBI::NodeWithComments
 
   sig { void }
   def translate_rbs_sigs!; end
-
-  private
-
-  sig { params(node: ::RBI::Node).returns(::RBI::Node) }
-  def create_node(node); end
-
-  sig { returns(T::Hash[::String, ::RBI::Node]) }
-  def nodes_cache; end
 end
 
 class RBI::Type
@@ -2608,9 +2573,15 @@ class RBI::Type
     sig { params(type: ::RBI::Type).returns(::RBI::Type::Class) }
     def t_class(type); end
 
+    sig { params(type: ::RBI::Type).returns(::RBI::Type::Module) }
+    def t_module(type); end
+
     sig { params(types: T.any(::RBI::Type, T::Array[::RBI::Type])).returns(::RBI::Type::Tuple) }
     def tuple(*types); end
 
+    sig { params(name: ::String, aliased_type: ::RBI::Type).returns(::RBI::Type::TypeAlias) }
+    def type_alias(name, aliased_type); end
+
     sig { params(name: ::Symbol).returns(::RBI::Type::TypeParameter) }
     def type_parameter(name); end
 
@@ -2637,6 +2608,9 @@ class RBI::Type
     sig { params(node: T.any(::Prism::ConstantPathNode, ::Prism::ConstantReadNode)).returns(::RBI::Type) }
     def parse_constant(node); end
 
+    sig { params(node: T.any(::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode)).returns(::RBI::Type) }
+    def parse_constant_assignment(node); end
+
     sig { params(node: ::Prism::CallNode).returns(::RBI::Type) }
     def parse_proc(node); end
 
@@ -2658,9 +2632,15 @@ class RBI::Type
     sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
     def t_class_of?(node); end
 
+    sig { params(node: ::Prism::ConstantPathNode).returns(T::Boolean) }
+    def t_module?(node); end
+
     sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
     def t_proc?(node); end
 
+    sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+    def t_type_alias?(node); end
+
     sig { params(name: ::String).returns(T::Boolean) }
     def valid_identifier?(name); end
   end
@@ -2814,6 +2794,26 @@ class RBI::Type::Generic < ::RBI::Type
   def to_rbi; end
 end
 
+class RBI::Type::Module < ::RBI::Type
+  sig { params(type: ::RBI::Type).void }
+  def initialize(type); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::RBI::Type) }
+  def normalize; end
+
+  sig { override.returns(::RBI::Type) }
+  def simplify; end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  sig { returns(::RBI::Type) }
+  def type; end
+end
+
 class RBI::Type::Nilable < ::RBI::Type
   sig { params(type: ::RBI::Type).void }
   def initialize(type); end
@@ -2960,6 +2960,29 @@ class RBI::Type::Tuple < ::RBI::Type
   def types; end
 end
 
+class RBI::Type::TypeAlias < ::RBI::Type
+  sig { params(name: ::String, aliased_type: ::RBI::Type).void }
+  def initialize(name, aliased_type); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(::RBI::Type) }
+  def aliased_type; end
+
+  sig { returns(::String) }
+  def name; end
+
+  sig { override.returns(::RBI::Type) }
+  def normalize; end
+
+  sig { override.returns(::RBI::Type) }
+  def simplify; end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
 class RBI::Type::TypeParameter < ::RBI::Type
   sig { params(name: ::Symbol).void }
   def initialize(name); end
@@ -3045,6 +3068,9 @@ class RBI::Type::Visitor
   sig { params(type: ::RBI::Type::Tuple).void }
   def visit_tuple(type); end
 
+  sig { params(type: ::RBI::Type::TypeAlias).void }
+  def visit_type_alias(type); end
+
   sig { params(type: ::RBI::Type::TypeParameter).void }
   def visit_type_parameter(type); end
 
@@ -3134,6 +3160,9 @@ class RBI::TypePrinter
   sig { params(type: ::RBI::Type::Generic).void }
   def visit_generic(type); end
 
+  sig { params(type: ::RBI::Type::Module).void }
+  def visit_module(type); end
+
   sig { params(type: ::RBI::Type::Nilable).void }
   def visit_nilable(type); end
 

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.8
 platform: ruby
 authors:
 - Alexandre Terrasa
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -37,6 +38,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.4.4
+description:
 email:
 - ruby@shopify.com
 executables: []
@@ -82,6 +84,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -96,7 +99,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.5.3
+signing_key:
 specification_version: 4
 summary: RBI generation framework
 test_files: []