rbi 0.3.3 → 0.3.5

data/lib/rbi/type_parser.rb

@@ -81,7 +81,7 @@ module RBI
           when Prism::ConstantReadNode
             # `Foo[Bar]` or `Foo[Bar, Baz]`
             args = check_arguments_at_least!(node, 1)
-            return T.unsafe(Type::Generic).new(recv.slice, *args.map { |arg| parse_node(arg) })
+            return Type::Generic.new(recv.slice, *args.map { |arg| parse_node(arg) })
           when Prism::ConstantPathNode
             if t_class?(recv)
               # `T::Class[Foo]` or `::T::Class[Foo]`
@@ -94,7 +94,7 @@ module RBI
             else
               # `::Foo[Bar]` or `::Foo[Bar, Baz]`
               args = check_arguments_at_least!(node, 1)
-              return T.unsafe(Type::Generic).new(recv.slice, *args.map { |arg| parse_node(arg) })
+              return Type::Generic.new(recv.slice, *args.map { |arg| parse_node(arg) })
             end
           when Prism::CallNode
             # `T.class_of(Foo)[Bar]`
@@ -183,7 +183,7 @@ module RBI
 
       #: (Prism::ArrayNode node) -> Type
       def parse_tuple(node)
-        T.unsafe(Type).tuple(*node.elements.map { |elem| parse_node(elem) })
+        Type.tuple(*node.elements.map { |elem| parse_node(elem) })
       end
 
       #: ((Prism::HashNode | Prism::KeywordHashNode) node) -> Type
@@ -204,7 +204,7 @@ module RBI
           end
           [key, parse_node(elem.value)]
         end.to_h
-        T.unsafe(Type).shape(**hash)
+        Type.shape(**hash)
       end
 
       #: (Prism::CallNode node) -> Type
@@ -229,7 +229,9 @@ module RBI
 
               [elem.key.slice.delete_suffix(":").to_sym, parse_node(elem.value)]
             end.to_h
-            T.unsafe(type).params(**params)
+            type.params(
+              **params, #: untyped
+            )
           when :returns
             args = check_arguments_exactly!(call, 1)
             type.returns(

data/lib/rbi/version.rb

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

data/lib/rbi/visitor.rb

@@ -4,11 +4,8 @@
 module RBI
   class VisitorError < Error; end
 
+  # @abstract
   class Visitor
-    extend T::Helpers
-
-    abstract!
-
     #: (Node? node) -> void
     def visit(node)
       return unless node

data/lib/rbi.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "stringio"
 require "rbs"
 

data/rbi/rbi.rbi

@@ -20,14 +20,10 @@ class RBI::Arg < ::RBI::Node
   def value; end
 end
 
-# Attributes
-#
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::Attr < ::RBI::NodeWithComments
   include ::RBI::Indexable
 
-  abstract!
-
   sig do
     params(
       name: ::Symbol,
@@ -433,24 +429,53 @@ class RBI::Group < ::RBI::Tree
   def kind; end
 end
 
-class RBI::Group::Kind < ::T::Enum
-  enums do
-    Attrs = new
-    Consts = new
-    Helpers = new
-    Inits = new
-    Methods = new
-    MixesInClassMethods = new
-    Mixins = new
-    RequiredAncestors = new
-    Sends = new
-    SingletonClasses = new
-    TEnums = new
-    TStructFields = new
-    TypeMembers = new
+class RBI::Group::Kind
+  class << self
+    private
+
+    def new(*_arg0); end
   end
 end
 
+# : Kind
+RBI::Group::Kind::Attrs = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::Consts = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::Helpers = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::Inits = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::Methods = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::MixesInClassMethods = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::Mixins = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::RequiredAncestors = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::Sends = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::SingletonClasses = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::TEnums = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::TStructFields = T.let(T.unsafe(nil), RBI::Group::Kind)
+
+# : Kind
+RBI::Group::Kind::TypeMembers = T.let(T.unsafe(nil), RBI::Group::Kind)
+
 class RBI::GroupNodesError < ::RBI::Error; end
 
 # Sorbet's misc.
@@ -532,11 +557,7 @@ class RBI::Index < ::RBI::Visitor
 end
 
 # A Node that can be referred to by a unique ID inside an index
-#
-# @abstract Subclasses must implement the `abstract` methods below.
 module RBI::Indexable
-  interface!
-
   # Unique IDs that refer to this node.
   #
   # Some nodes can have multiple ids, for example an attribute accessor matches the ID of the
@@ -646,6 +667,9 @@ class RBI::Loc
   sig { returns(T.nilable(::String)) }
   def file; end
 
+  sig { params(other: ::RBI::Loc).returns(::RBI::Loc) }
+  def join(other); end
+
   sig { returns(T.nilable(::String)) }
   def source; end
 
@@ -798,12 +822,8 @@ class RBI::MixesInClassMethods < ::RBI::Mixin
   def to_s; end
 end
 
-# Mixins
-#
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::Mixin < ::RBI::NodeWithComments
-  abstract!
-
   sig do
     params(
       name: ::String,
@@ -845,10 +865,8 @@ class RBI::Module < ::RBI::Scope
   def name=(_arg0); end
 end
 
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::Node
-  abstract!
-
   sig { params(loc: T.nilable(::RBI::Loc)).void }
   def initialize(loc: T.unsafe(nil)); end
 
@@ -915,10 +933,8 @@ class RBI::Node
   def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
 end
 
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::NodeWithComments < ::RBI::Node
-  abstract!
-
   sig { params(loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
@@ -957,10 +973,8 @@ class RBI::OptParam < ::RBI::Param
   def value; end
 end
 
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::Param < ::RBI::NodeWithComments
-  abstract!
-
   sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
@@ -1506,10 +1520,11 @@ class RBI::RBSPrinter < ::RBI::Visitor
       out: T.any(::IO, ::StringIO),
       indent: ::Integer,
       print_locs: T::Boolean,
-      positional_names: T::Boolean
+      positional_names: T::Boolean,
+      max_line_length: T.nilable(::Integer)
     ).void
   end
-  def initialize(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), positional_names: T.unsafe(nil)); end
+  def initialize(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), positional_names: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
 
   sig { returns(::Integer) }
   def current_indent; end
@@ -1527,6 +1542,9 @@ class RBI::RBSPrinter < ::RBI::Visitor
   sig { void }
   def indent; end
 
+  sig { returns(T.nilable(::Integer)) }
+  def max_line_length; end
+
   sig { returns(T::Boolean) }
   def positional_names; end
 
@@ -1552,6 +1570,12 @@ class RBI::RBSPrinter < ::RBI::Visitor
   sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void }
   def print_method_sig(node, sig); end
 
+  sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void }
+  def print_method_sig_inline(node, sig); end
+
+  sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void }
+  def print_method_sig_multiline(node, sig); end
+
   # Print a string with indentation and `\n` at the end.
   sig { params(string: ::String).void }
   def printl(string); end
@@ -2052,18 +2076,24 @@ class RBI::Rewriters::Merge
 end
 
 # Used for logging / error displaying purpose
-class RBI::Rewriters::Merge::Conflict < ::T::Struct
-  const :left, ::RBI::Node
-  const :right, ::RBI::Node
-  const :left_name, ::String
-  const :right_name, ::String
+class RBI::Rewriters::Merge::Conflict
+  sig { params(left: ::RBI::Node, right: ::RBI::Node, left_name: ::String, right_name: ::String).void }
+  def initialize(left:, right:, left_name:, right_name:); end
+
+  sig { returns(::RBI::Node) }
+  def left; end
 
   sig { returns(::String) }
-  def to_s; end
+  def left_name; end
 
-  class << self
-    def inherited(s); end
-  end
+  # @return [Node]
+  def right; end
+
+  # @return [String]
+  def right_name; end
+
+  sig { returns(::String) }
+  def to_s; end
 end
 
 # Merge adjacent conflict trees
@@ -2109,14 +2139,23 @@ class RBI::Rewriters::Merge::ConflictTreeMerger < ::RBI::Visitor
   def merge_conflict_trees(left, right); end
 end
 
-class RBI::Rewriters::Merge::Keep < ::T::Enum
-  enums do
-    LEFT = new
-    NONE = new
-    RIGHT = new
+class RBI::Rewriters::Merge::Keep
+  class << self
+    private
+
+    def new(*_arg0); end
   end
 end
 
+# : Keep
+RBI::Rewriters::Merge::Keep::LEFT = T.let(T.unsafe(nil), RBI::Rewriters::Merge::Keep)
+
+# : Keep
+RBI::Rewriters::Merge::Keep::NONE = T.let(T.unsafe(nil), RBI::Rewriters::Merge::Keep)
+
+# : Keep
+RBI::Rewriters::Merge::Keep::RIGHT = T.let(T.unsafe(nil), RBI::Rewriters::Merge::Keep)
+
 class RBI::Rewriters::Merge::TreeMerger < ::RBI::Visitor
   sig do
     params(
@@ -2263,16 +2302,18 @@ class RBI::Rewriters::RemoveKnownDefinitions < ::RBI::Visitor
   end
 end
 
-class RBI::Rewriters::RemoveKnownDefinitions::Operation < ::T::Struct
-  const :deleted_node, ::RBI::Node
-  const :duplicate_of, ::RBI::Node
+class RBI::Rewriters::RemoveKnownDefinitions::Operation
+  sig { params(deleted_node: ::RBI::Node, duplicate_of: ::RBI::Node).void }
+  def initialize(deleted_node:, duplicate_of:); end
+
+  sig { returns(::RBI::Node) }
+  def deleted_node; end
+
+  # @return [Node]
+  def duplicate_of; end
 
   sig { returns(::String) }
   def to_s; end
-
-  class << self
-    def inherited(s); end
-  end
 end
 
 class RBI::Rewriters::SortNodes < ::RBI::Visitor
@@ -2313,14 +2354,10 @@ end
 
 class RBI::Rewriters::TranslateRBSSigs::Error < ::RBI::Error; end
 
-# Scopes
-#
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::Scope < ::RBI::Tree
   include ::RBI::Indexable
 
-  abstract!
-
   # Duplicate `self` scope without its body
   sig { returns(T.self_type) }
   def dup_empty; end
@@ -2661,10 +2698,8 @@ class RBI::TStructConst < ::RBI::TStructField
   def to_s; end
 end
 
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::TStructField < ::RBI::NodeWithComments
-  abstract!
-
   sig do
     params(
       name: ::String,
@@ -2864,10 +2899,8 @@ end
 
 # The base class for all RBI types.
 #
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::Type
-  abstract!
-
   sig { void }
   def initialize; end
 
@@ -2910,9 +2943,33 @@ class RBI::Type
   sig { returns(::RBI::Type) }
   def non_nilable; end
 
+  # Returns a normalized version of the type.
+  #
+  # Normalized types are meant to be easier to process, not to read.
+  # For example, `T.any(TrueClass, FalseClass)` instead of `T::Boolean` or
+  # `T.any(String, NilClass)` instead of `T.nilable(String)`.
+  #
+  # This is the inverse of `#simplify`.
+  #
+  # @abstract
+  sig { abstract.returns(::RBI::Type) }
+  def normalize; end
+
   sig { returns(::String) }
   def rbs_string; end
 
+  # Returns a simplified version of the type.
+  #
+  # Simplified types are meant to be easier to read, not to process.
+  # For example, `T::Boolean` instead of `T.any(TrueClass, FalseClass)` or
+  # `T.nilable(String)` instead of `T.any(String, NilClass)`.
+  #
+  # This is the inverse of `#normalize`.
+  #
+  # @abstract
+  sig { abstract.returns(::RBI::Type) }
+  def simplify; end
+
   # @abstract
   sig { abstract.returns(::String) }
   def to_rbi; end
@@ -3063,6 +3120,12 @@ end
 
 # A type that is intersection of multiple types like `T.all(String, Integer)`.
 class RBI::Type::All < ::RBI::Type::Composite
+  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
@@ -3072,6 +3135,12 @@ class RBI::Type::Any < ::RBI::Type::Composite
   sig { returns(T::Boolean) }
   def nilable?; 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
@@ -3081,6 +3150,12 @@ class RBI::Type::Anything < ::RBI::Type
   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
 end
@@ -3090,6 +3165,12 @@ class RBI::Type::AttachedClass < ::RBI::Type
   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
 end
@@ -3099,6 +3180,12 @@ class RBI::Type::Boolean < ::RBI::Type
   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
 end
@@ -3111,6 +3198,12 @@ class RBI::Type::Class < ::RBI::Type
   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
 
@@ -3126,6 +3219,12 @@ class RBI::Type::ClassOf < ::RBI::Type
   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
 
@@ -3138,10 +3237,8 @@ end
 
 # A type that is composed of multiple types like `T.all(String, Integer)`.
 #
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::Type::Composite < ::RBI::Type
-  abstract!
-
   sig { params(types: T::Array[::RBI::Type]).void }
   def initialize(types); end
 
@@ -3165,9 +3262,15 @@ class RBI::Type::Generic < ::RBI::Type
   sig { returns(::String) }
   def name; end
 
+  sig { override.returns(::RBI::Type) }
+  def normalize; end
+
   sig { returns(T::Array[::RBI::Type]) }
   def params; end
 
+  sig { override.returns(::RBI::Type) }
+  def simplify; end
+
   sig { override.returns(::String) }
   def to_rbi; end
 end
@@ -3180,6 +3283,12 @@ class RBI::Type::Nilable < ::RBI::Type
   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
 
@@ -3192,6 +3301,12 @@ class RBI::Type::NoReturn < ::RBI::Type
   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
 end
@@ -3207,6 +3322,9 @@ class RBI::Type::Proc < ::RBI::Type
   sig { params(type: T.untyped).returns(T.self_type) }
   def bind(type); end
 
+  sig { override.returns(::RBI::Type) }
+  def normalize; end
+
   sig { params(params: ::RBI::Type).returns(T.self_type) }
   def params(**params); end
 
@@ -3222,6 +3340,9 @@ class RBI::Type::Proc < ::RBI::Type
   sig { params(type: T.untyped).returns(T.self_type) }
   def returns(type); end
 
+  sig { override.returns(::RBI::Type) }
+  def simplify; end
+
   sig { override.returns(::String) }
   def to_rbi; end
 
@@ -3234,6 +3355,12 @@ class RBI::Type::SelfType < ::RBI::Type
   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
 end
@@ -3246,6 +3373,12 @@ class RBI::Type::Shape < ::RBI::Type
   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
 
@@ -3266,6 +3399,12 @@ class RBI::Type::Simple < ::RBI::Type
   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
@@ -3278,6 +3417,12 @@ class RBI::Type::Tuple < ::RBI::Type
   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
 
@@ -3296,6 +3441,12 @@ class RBI::Type::TypeParameter < ::RBI::Type
   sig { returns(::Symbol) }
   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
@@ -3305,6 +3456,12 @@ class RBI::Type::Untyped < ::RBI::Type
   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
 end
@@ -3377,6 +3534,12 @@ class RBI::Type::Void < ::RBI::Type
   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
 end
@@ -3412,8 +3575,8 @@ class RBI::TypeMember < ::RBI::NodeWithComments
 end
 
 class RBI::TypePrinter
-  sig { void }
-  def initialize; end
+  sig { params(max_line_length: T.nilable(::Integer)).void }
+  def initialize(max_line_length: T.unsafe(nil)); end
 
   sig { returns(::String) }
   def string; end
@@ -3502,12 +3665,8 @@ end
 
 RBI::VERSION = T.let(T.unsafe(nil), String)
 
-# Visibility
-#
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::Visibility < ::RBI::NodeWithComments
-  abstract!
-
   sig { params(visibility: ::Symbol, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
   def initialize(visibility, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
@@ -3535,10 +3694,8 @@ class RBI::VisibilityGroup < ::RBI::Tree
   def visibility; end
 end
 
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+# @abstract
 class RBI::Visitor
-  abstract!
-
   sig { params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end