rbi 0.0.2 → 0.0.6

data/lib/rbi/model.rb

@@ -48,7 +48,7 @@ module RBI
   end
 
   class Comment < Node
-    extend T::Helpers
+    extend T::Sig
 
     sig { returns(String) }
     attr_accessor :text
@@ -66,6 +66,15 @@ module RBI
     end
   end
 
+  class EmptyComment < Comment
+    extend T::Sig
+
+    sig { params(loc: T.nilable(Loc)).void }
+    def initialize(loc: nil)
+      super("", loc: loc)
+    end
+  end
+
   class NodeWithComments < Node
     extend T::Sig
     extend T::Helpers
@@ -92,7 +101,7 @@ module RBI
       params(
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
-        block: T.nilable(T.proc.params(tree: Tree).void)
+        block: T.nilable(T.proc.params(node: Tree).void)
       ).void
     end
     def initialize(loc: nil, comments: [], &block)
@@ -129,7 +138,7 @@ module RBI
       params(
         strictness: T.nilable(String),
         comments: T::Array[Comment],
-        block: T.nilable(T.proc.params(mod: File).void)
+        block: T.nilable(T.proc.params(file: File).void)
       ).void
     end
     def initialize(strictness: nil, comments: [], &block)
@@ -172,7 +181,7 @@ module RBI
         name: String,
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
-        block: T.nilable(T.proc.params(mod: Module).void)
+        block: T.nilable(T.proc.params(node: Module).void)
       ).void
     end
     def initialize(name, loc: nil, comments: [], &block)
@@ -203,7 +212,7 @@ module RBI
         superclass_name: T.nilable(String),
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
-        block: T.nilable(T.proc.params(klass: Class).void)
+        block: T.nilable(T.proc.params(node: Class).void)
       ).void
     end
     def initialize(name, superclass_name: nil, loc: nil, comments: [], &block)
@@ -227,7 +236,7 @@ module RBI
       params(
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
-        block: T.nilable(T.proc.params(klass: SingletonClass).void)
+        block: T.nilable(T.proc.params(node: SingletonClass).void)
       ).void
     end
     def initialize(loc: nil, comments: [], &block)
@@ -241,6 +250,43 @@ module RBI
     end
   end
 
+  class Struct < Scope
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_accessor :name
+
+    sig { returns(T::Array[Symbol]) }
+    attr_accessor :members
+
+    sig { returns(T::Boolean) }
+    attr_accessor :keyword_init
+
+    sig do
+      params(
+        name: String,
+        members: T::Array[Symbol],
+        keyword_init: T::Boolean,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(struct: Struct).void)
+      ).void
+    end
+    def initialize(name, members: [], keyword_init: false, loc: nil, comments: [], &block)
+      super(loc: loc, comments: comments) {}
+      @name = name
+      @members = members
+      @keyword_init = keyword_init
+      block&.call(self)
+    end
+
+    sig { override.returns(String) }
+    def fully_qualified_name
+      return name if name.start_with?("::")
+      "#{parent_scope&.fully_qualified_name}::#{name}"
+    end
+  end
+
   # Consts
 
   class Const < NodeWithComments
@@ -249,11 +295,20 @@ module RBI
     sig { returns(String) }
     attr_reader :name, :value
 
-    sig { params(name: String, value: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
-    def initialize(name, value, loc: nil, comments: [])
+    sig do
+      params(
+        name: String,
+        value: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: Const).void)
+      ).void
+    end
+    def initialize(name, value, loc: nil, comments: [], &block)
       super(loc: loc, comments: comments)
       @name = name
       @value = value
+      block&.call(self)
     end
 
     sig { returns(String) }
@@ -288,14 +343,14 @@ module RBI
     sig do
       params(
         name: Symbol,
-        names: Symbol,
+        names: T::Array[Symbol],
         visibility: Visibility,
         sigs: T::Array[Sig],
         loc: T.nilable(Loc),
         comments: T::Array[Comment]
       ).void
     end
-    def initialize(name, *names, visibility: Visibility::Public, sigs: [], loc: nil, comments: [])
+    def initialize(name, names, visibility: Public.new, sigs: [], loc: nil, comments: [])
       super(loc: loc, comments: comments)
       @names = T.let([name, *names], T::Array[Symbol])
       @visibility = visibility
@@ -309,6 +364,22 @@ module RBI
   class AttrAccessor < Attr
     extend T::Sig
 
+    sig do
+      params(
+        name: Symbol,
+        names: Symbol,
+        visibility: Visibility,
+        sigs: T::Array[Sig],
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: AttrAccessor).void)
+      ).void
+    end
+    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)
+    end
+
     sig { override.returns(T::Array[String]) }
     def fully_qualified_names
       parent_name = parent_scope&.fully_qualified_name
@@ -325,6 +396,22 @@ module RBI
   class AttrReader < Attr
     extend T::Sig
 
+    sig do
+      params(
+        name: Symbol,
+        names: Symbol,
+        visibility: Visibility,
+        sigs: T::Array[Sig],
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: AttrReader).void)
+      ).void
+    end
+    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)
+    end
+
     sig { override.returns(T::Array[String]) }
     def fully_qualified_names
       parent_name = parent_scope&.fully_qualified_name
@@ -341,6 +428,22 @@ module RBI
   class AttrWriter < Attr
     extend T::Sig
 
+    sig do
+      params(
+        name: Symbol,
+        names: Symbol,
+        visibility: Visibility,
+        sigs: T::Array[Sig],
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: AttrWriter).void)
+      ).void
+    end
+    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)
+    end
+
     sig { override.returns(T::Array[String]) }
     def fully_qualified_names
       parent_name = parent_scope&.fully_qualified_name
@@ -383,14 +486,14 @@ module RBI
         sigs: T::Array[Sig],
         loc: T.nilable(Loc),
         comments: T::Array[Comment],
-        block: T.nilable(T.proc.params(mod: Method).void)
+        block: T.nilable(T.proc.params(node: Method).void)
       ).void
     end
     def initialize(
       name,
       params: [],
       is_singleton: false,
-      visibility: Visibility::Public,
+      visibility: Public.new,
       sigs: [],
       loc: nil,
       comments: [],
@@ -426,12 +529,21 @@ module RBI
   end
 
   class Param < NodeWithComments
+    extend T::Helpers
     extend T::Sig
 
+    abstract!
+
     sig { returns(String) }
     attr_reader :name
 
-    sig { params(name: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+      ).void
+    end
     def initialize(name, loc: nil, comments: [])
       super(loc: loc, comments: comments)
       @name = name
@@ -441,11 +553,27 @@ module RBI
     def to_s
       name
     end
+  end
+
+  class ReqParam < Param
+    extend T::Sig
+
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: ReqParam).void)
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [], &block)
+      super(name, loc: loc, comments: comments)
+      block&.call(self)
+    end
 
     sig { params(other: T.nilable(Object)).returns(T::Boolean) }
     def ==(other)
-      return false unless other.instance_of?(Param)
-      name == T.cast(other, Param).name
+      ReqParam === other && name == other.name
     end
   end
 
@@ -455,39 +583,70 @@ module RBI
     sig { returns(String) }
     attr_reader :value
 
-    sig { params(name: String, value: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
-    def initialize(name, value, loc: nil, comments: [])
+    sig do
+      params(
+        name: String,
+        value: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: OptParam).void)
+      ).void
+    end
+    def initialize(name, value, loc: nil, comments: [], &block)
       super(name, loc: loc, comments: comments)
       @value = value
+      block&.call(self)
     end
 
     sig { params(other: T.nilable(Object)).returns(T::Boolean) }
     def ==(other)
-      return false unless other.instance_of?(OptParam)
-      other = T.cast(other, OptParam)
-      return false unless name == other.name
-      value == other.value
+      OptParam === other && name == other.name && value == other.value
     end
   end
 
   class RestParam < Param
     extend T::Sig
 
-    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
-    def ==(other)
-      return false unless other.instance_of?(RestParam)
-      name == T.cast(other, RestParam).name
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: RestParam).void)
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [], &block)
+      super(name, loc: loc, comments: comments)
+      block&.call(self)
     end
 
     sig { override.returns(String) }
     def to_s
       "*#{name}"
     end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      RestParam === other && name == other.name
+    end
   end
 
   class KwParam < Param
     extend T::Sig
 
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: KwParam).void)
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [], &block)
+      super(name, loc: loc, comments: comments)
+      block&.call(self)
+    end
+
     sig { override.returns(String) }
     def to_s
       "#{name}:"
@@ -495,14 +654,31 @@ module RBI
 
     sig { params(other: T.nilable(Object)).returns(T::Boolean) }
     def ==(other)
-      return false unless other.instance_of?(KwParam)
-      name == T.cast(other, KwParam).name
+      KwParam === other && name == other.name
     end
   end
 
-  class KwOptParam < OptParam
+  class KwOptParam < Param
     extend T::Sig
 
+    sig { returns(String) }
+    attr_reader :value
+
+    sig do
+      params(
+        name: String,
+        value: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: KwOptParam).void)
+      ).void
+    end
+    def initialize(name, value, loc: nil, comments: [], &block)
+      super(name, loc: loc, comments: comments)
+      @value = value
+      block&.call(self)
+    end
+
     sig { override.returns(String) }
     def to_s
       "#{name}:"
@@ -510,16 +686,26 @@ module RBI
 
     sig { params(other: T.nilable(Object)).returns(T::Boolean) }
     def ==(other)
-      return false unless other.instance_of?(KwOptParam)
-      other = T.cast(other, KwOptParam)
-      return false unless name == other.name
-      value == other.value
+      KwOptParam === other && name == other.name && value == other.value
     end
   end
 
   class KwRestParam < Param
     extend T::Sig
 
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: KwRestParam).void)
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [], &block)
+      super(name, loc: loc, comments: comments)
+      block&.call(self)
+    end
+
     sig { override.returns(String) }
     def to_s
       "**#{name}:"
@@ -527,14 +713,26 @@ module RBI
 
     sig { params(other: T.nilable(Object)).returns(T::Boolean) }
     def ==(other)
-      return false unless other.instance_of?(KwRestParam)
-      name == T.cast(other, KwRestParam).name
+      KwRestParam === other && name == other.name
     end
   end
 
   class BlockParam < Param
     extend T::Sig
 
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: BlockParam).void)
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [], &block)
+      super(name, loc: loc, comments: comments)
+      block&.call(self)
+    end
+
     sig { override.returns(String) }
     def to_s
       "&#{name}"
@@ -542,8 +740,7 @@ module RBI
 
     sig { params(other: T.nilable(Object)).returns(T::Boolean) }
     def ==(other)
-      return false unless other.instance_of?(BlockParam)
-      name == T.cast(other, BlockParam).name
+      BlockParam === other && name == other.name
     end
   end
 
@@ -558,8 +755,15 @@ module RBI
     sig { returns(T::Array[String]) }
     attr_accessor :names
 
-    sig { params(name: String, names: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
-    def initialize(name, *names, loc: nil, comments: [])
+    sig do
+      params(
+        name: String,
+        names: T::Array[String],
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment]
+      ).void
+    end
+    def initialize(name, names, loc: nil, comments: [])
       super(loc: loc, comments: comments)
       @names = T.let([name, *names], T::Array[String])
     end
@@ -568,6 +772,20 @@ module RBI
   class Include < Mixin
     extend T::Sig
 
+    sig do
+      params(
+        name: String,
+        names: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: Include).void)
+      ).void
+    end
+    def initialize(name, *names, loc: nil, comments: [], &block)
+      super(name, names, loc: loc, comments: comments)
+      block&.call(self)
+    end
+
     sig { override.returns(String) }
     def to_s
       "#{parent_scope&.fully_qualified_name}.include(#{names.join(", ")})"
@@ -577,6 +795,20 @@ module RBI
   class Extend < Mixin
     extend T::Sig
 
+    sig do
+      params(
+        name: String,
+        names: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: Extend).void)
+      ).void
+    end
+    def initialize(name, *names, loc: nil, comments: [], &block)
+      super(name, names, loc: loc, comments: comments)
+      block&.call(self)
+    end
+
     sig { override.returns(String) }
     def to_s
       "#{parent_scope&.fully_qualified_name}.extend(#{names.join(", ")})"
@@ -585,7 +817,7 @@ module RBI
 
   # Visibility
 
-  class Visibility < Node
+  class Visibility < NodeWithComments
     extend T::Sig
     extend T::Helpers
 
@@ -594,9 +826,9 @@ module RBI
     sig { returns(Symbol) }
     attr_reader :visibility
 
-    sig { params(visibility: Symbol, loc: T.nilable(Loc)).void }
-    def initialize(visibility, loc: nil)
-      super(loc: loc)
+    sig { params(visibility: Symbol, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
+    def initialize(visibility, loc: nil, comments: [])
+      super(loc: loc, comments: comments)
       @visibility = visibility
     end
 
@@ -605,9 +837,68 @@ module RBI
       visibility == other.visibility
     end
 
-    Public = T.let(Visibility.new(:public), Visibility)
-    Protected = T.let(Visibility.new(:protected), Visibility)
-    Private = T.let(Visibility.new(:private), Visibility)
+    sig { returns(T::Boolean) }
+    def public?
+      visibility == :public
+    end
+
+    sig { returns(T::Boolean) }
+    def protected?
+      visibility == :protected
+    end
+
+    sig { returns(T::Boolean) }
+    def private?
+      visibility == :private
+    end
+  end
+
+  class Public < Visibility
+    extend T::Sig
+
+    sig do
+      params(
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: Public).void)
+      ).void
+    end
+    def initialize(loc: nil, comments: [], &block)
+      super(:public, loc: loc, comments: comments)
+      block&.call(self)
+    end
+  end
+
+  class Protected < Visibility
+    extend T::Sig
+
+    sig do
+      params(
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: Protected).void)
+      ).void
+    end
+    def initialize(loc: nil, comments: [], &block)
+      super(:protected, loc: loc, comments: comments)
+      block&.call(self)
+    end
+  end
+
+  class Private < Visibility
+    extend T::Sig
+
+    sig do
+      params(
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: Private).void)
+      ).void
+    end
+    def initialize(loc: nil, comments: [], &block)
+      super(:private, loc: loc, comments: comments)
+      block&.call(self)
+    end
   end
 
   # Sorbet's sigs
@@ -639,7 +930,8 @@ module RBI
         is_overridable: T::Boolean,
         type_params: T::Array[String],
         checked: T.nilable(Symbol),
-        loc: T.nilable(Loc)
+        loc: T.nilable(Loc),
+        block: T.nilable(T.proc.params(node: Sig).void)
       ).void
     end
     def initialize(
@@ -650,7 +942,8 @@ module RBI
       is_overridable: false,
       type_params: [],
       checked: nil,
-      loc: nil
+      loc: nil,
+      &block
     )
       super(loc: loc)
       @params = params
@@ -660,6 +953,7 @@ module RBI
       @is_overridable = is_overridable
       @type_params = type_params
       @checked = checked
+      block&.call(self)
     end
 
     sig { params(param: SigParam).void }
@@ -676,17 +970,26 @@ module RBI
     end
   end
 
-  class SigParam < Node
+  class SigParam < NodeWithComments
     extend T::Sig
 
     sig { returns(String) }
     attr_reader :name, :type
 
-    sig { params(name: String, type: String, loc: T.nilable(Loc)).void }
-    def initialize(name, type, loc: nil)
-      super(loc: loc)
+    sig do
+      params(
+        name: String,
+        type: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: SigParam).void)
+      ).void
+    end
+    def initialize(name, type, loc: nil, comments: [], &block)
+      super(loc: loc, comments: comments)
       @name = name
       @type = type
+      block&.call(self)
     end
 
     sig { params(other: Object).returns(T::Boolean) }
@@ -749,6 +1052,21 @@ module RBI
   class TStructConst < TStructField
     extend T::Sig
 
+    sig do
+      params(
+        name: String,
+        type: String,
+        default: T.nilable(String),
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: TStructConst).void)
+      ).void
+    end
+    def initialize(name, type, default: nil, loc: nil, comments: [], &block)
+      super(name, type, default: default, loc: loc, comments: comments)
+      block&.call(self)
+    end
+
     sig { override.returns(T::Array[String]) }
     def fully_qualified_names
       parent_name = parent_scope&.fully_qualified_name
@@ -764,6 +1082,21 @@ module RBI
   class TStructProp < TStructField
     extend T::Sig
 
+    sig do
+      params(
+        name: String,
+        type: String,
+        default: T.nilable(String),
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: TStructProp).void)
+      ).void
+    end
+    def initialize(name, type, default: nil, loc: nil, comments: [], &block)
+      super(name, type, default: default, loc: loc, comments: comments)
+      block&.call(self)
+    end
+
     sig { override.returns(T::Array[String]) }
     def fully_qualified_names
       parent_name = parent_scope&.fully_qualified_name
@@ -801,10 +1134,18 @@ module RBI
     sig { returns(T::Array[String]) }
     attr_reader :names
 
-    sig { params(names: T::Array[String], loc: T.nilable(Loc), comments: T::Array[Comment]).void }
-    def initialize(names = [], loc: nil, comments: [])
+    sig do
+      params(
+        names: T::Array[String],
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: TEnumBlock).void)
+      ).void
+    end
+    def initialize(names = [], loc: nil, comments: [], &block)
       super(loc: loc, comments: comments)
       @names = names
+      block&.call(self)
     end
 
     sig { returns(T::Boolean) }
@@ -831,10 +1172,18 @@ module RBI
     sig { returns(String) }
     attr_reader :name
 
-    sig { params(name: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
-    def initialize(name, loc: nil, comments: [])
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: Helper).void)
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [], &block)
       super(loc: loc, comments: comments)
       @name = name
+      block&.call(self)
     end
 
     sig { override.returns(String) }
@@ -849,11 +1198,20 @@ module RBI
     sig { returns(String) }
     attr_reader :name, :value
 
-    sig { params(name: String, value: String, loc: T.nilable(Loc), comments: T::Array[Comment]).void }
-    def initialize(name, value, loc: nil, comments: [])
+    sig do
+      params(
+        name: String,
+        value: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: TypeMember).void)
+      ).void
+    end
+    def initialize(name, value, loc: nil, comments: [], &block)
       super(loc: loc, comments: comments)
       @name = name
       @value = value
+      block&.call(self)
     end
 
     sig { returns(String) }
@@ -871,6 +1229,20 @@ module RBI
   class MixesInClassMethods < Mixin
     extend T::Sig
 
+    sig do
+      params(
+        name: String,
+        names: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: MixesInClassMethods).void)
+      ).void
+    end
+    def initialize(name, *names, loc: nil, comments: [], &block)
+      super(name, names, loc: loc, comments: comments)
+      block&.call(self)
+    end
+
     sig { override.returns(String) }
     def to_s
       "#{parent_scope&.fully_qualified_name}.mixes_in_class_methods(#{names.join(", ")})"