rbi 0.3.2 → 0.3.5

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
 
@@ -1013,10 +1027,10 @@ class RBI::Parser::HeredocLocationVisitor < ::Prism::Visitor
   sig { returns(::Prism::Location) }
   def location; end
 
-  sig { params(node: ::Prism::InterpolatedStringNode).void }
+  sig { override.params(node: ::Prism::InterpolatedStringNode).void }
   def visit_interpolated_string_node(node); end
 
-  sig { params(node: ::Prism::StringNode).void }
+  sig { override.params(node: ::Prism::StringNode).void }
   def visit_string_node(node); end
 
   private
@@ -1153,6 +1167,12 @@ class RBI::Parser::Visitor < ::Prism::Visitor
 
   sig { params(node: ::Prism::Node).returns(::String) }
   def node_string!(node); end
+
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def self?(node); end
+
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def t_sig_without_runtime?(node); end
 end
 
 class RBI::Printer < ::RBI::Visitor
@@ -1500,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
@@ -1521,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
 
@@ -1546,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
@@ -2046,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
@@ -2103,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(
@@ -2257,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
@@ -2307,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
@@ -2407,6 +2450,7 @@ class RBI::Sig < ::RBI::NodeWithComments
       is_overridable: T::Boolean,
       is_final: T::Boolean,
       allow_incompatible_override: T::Boolean,
+      without_runtime: T::Boolean,
       type_params: T::Array[::String],
       checked: T.nilable(::Symbol),
       loc: T.nilable(::RBI::Loc),
@@ -2414,7 +2458,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), 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), 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
@@ -2472,6 +2516,12 @@ class RBI::Sig < ::RBI::NodeWithComments
 
   sig { returns(T::Array[::String]) }
   def type_params; end
+
+  # @return [Boolean]
+  def without_runtime; end
+
+  # @return [Boolean]
+  def without_runtime=(_arg0); end
 end
 
 class RBI::SigParam < ::RBI::NodeWithComments
@@ -2648,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,
@@ -2851,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
 
@@ -2897,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
@@ -3050,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
@@ -3059,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
@@ -3068,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
@@ -3077,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
@@ -3086,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
@@ -3098,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
 
@@ -3113,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
 
@@ -3125,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
 
@@ -3152,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
@@ -3167,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
 
@@ -3179,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
@@ -3194,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
 
@@ -3209,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
 
@@ -3221,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
@@ -3233,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
 
@@ -3253,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
@@ -3265,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
 
@@ -3283,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
@@ -3292,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
@@ -3364,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
@@ -3399,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
@@ -3489,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
 
@@ -3522,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