rbi 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80df141e229452edf3fb51dc8933c130ce2a2f972ee6906be79680d79f33a720
-  data.tar.gz: '099a5b5fb43ccd50cf262bcdbc0d8fde6cd0aa14983851c9de14f488def2a56b'
+  metadata.gz: d0977bf3c0892a76c8d66ec2f295a62948530bcd2eee11911c50e36ac1bf5402
+  data.tar.gz: ae51e44eb13fe8045f200a8a0353daa9969c4389f99c73758713fa0a9b2b9b0f
 SHA512:
-  metadata.gz: 791d993759d3e237a52d34be622c23eec92d1adb26b267aa47b3aa9e7ce1767b96fff75e02d895493fb63b84fe3f15cb1c37f880db1698e5a8b9e17cba77503e
-  data.tar.gz: cdf11ef801d7ac8a1329b39e095c4895d006ae46ad800d50d1d2cb52aa9c41fdb704557a8a660376b53e4bdb86a076bacde0a5a2c33d0031478dda36850297b1
+  metadata.gz: 32bafbbfffee840fe60a1633eb8b408aca4c8e39b5359ce3deca5185ab3003ac43b6c6cab4c4639d9e87e12afabcf1ee042bc9b5a56a231302354f884b2c27ea
+  data.tar.gz: da025803fafaf40714356d02dfe77a705a0de38050bdce9616c6e35f68479b958aa0eb5b596ddf146ef1493932a70fead22f7cb745a28e7c15a40ee85a850c2e

data/Gemfile

@@ -10,7 +10,7 @@ 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)

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

@@ -34,7 +34,7 @@ module RBI
           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 +85,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?

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

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

@@ -583,6 +583,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]`.
@@ -871,6 +911,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]`.
@@ -957,7 +1003,7 @@ module RBI
     #
     # @abstract
     #: -> Type
-    def normalize; end
+    def normalize = raise NotImplementedError, "Abstract method called"
 
     # Returns a simplified version of the type.
     #
@@ -969,11 +1015,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 +1034,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
@@ -310,6 +335,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)

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.7"
 end

data/rbi/rbi.rbi

@@ -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
 
@@ -2611,6 +2636,9 @@ class RBI::Type
     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 +2665,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
 
@@ -2661,6 +2692,9 @@ class RBI::Type
     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
@@ -2960,6 +2994,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 +3102,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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors:
 - Alexandre Terrasa
@@ -96,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.2
 specification_version: 4
 summary: RBI generation framework
 test_files: []