rbi 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f74d8bfd9f52c65d39357d68e286e247a48d53779397c11f310b50ca37b3b925
-  data.tar.gz: 0a924a9c84c508cbb70b307a1b8770f00b1c855d68c41c57e0dd74dfd1f75d86
+  metadata.gz: 80af4a72c6b71d1ed72dd5eefc9c2821443cbb7ca00d458bbfd2a381e1297545
+  data.tar.gz: 8d774a3c7094a748a6fab5623eb6da0f5097e00591696e4e22423f3de6a869ee
 SHA512:
-  metadata.gz: 303c4606968022e24e65f0d9a54732431ee7c6cc315dffe592e0196e5c449a5842319d32897231f046ca8266ccaf3dc9743fd7229582988b5a590c381cf4473b
-  data.tar.gz: 955d836aea51639220440f984fa0a8c595c763521b84ddca73dfdd08b8b546bc5b61e3fc48a19ddd04e50a7824377cc25960816a9ac2d65454ab8821259acda8
+  metadata.gz: 259201aa73a41ef445010bb89bd14f69df1ef107dcfdf1becda6ead491ce067d6a0cbb9520f751272a879d76d65c74bb524a67c037447f74e243fd429749fbe7
+  data.tar.gz: b989d25962cca475a307fcf1e76c8c74d74b3079290532e7be0bd3901446dbc800242641557ddc51e3cf2977970059869228f58bef0ff372537ef934b3a46eb2

data/README.md

@@ -60,7 +60,7 @@ This repo uses itself (`rbi`) to retrieve and generate gem RBIs. You can run `de
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rbi. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/rbi/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/rbi. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/Shopify/rbi/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 

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(", ")})"