rbs 2.8.4 → 3.8.1

data/sig/members.rbs

@@ -15,6 +15,26 @@ module RBS
       type visibility = :public | :private
 
       class MethodDefinition < Base
+        class Overload
+          attr_reader method_type: MethodType
+
+          attr_reader annotations: Array[Annotation]
+
+          def initialize: (method_type: MethodType, annotations: Array[Annotation]) -> void
+
+          def ==: (untyped) -> bool
+
+          def hash: () -> Integer
+
+          alias eql? ==
+
+          def update: (?annotations: Array[Annotation], ?method_type: MethodType) -> Overload
+
+          def sub: (Substitution) -> Overload
+
+          include _ToJson
+        end
+
         type kind = :instance | :singleton | :singleton_instance
 
         # def foo: () -> void
@@ -26,31 +46,35 @@ module RBS
         #         ^^^                              keyword
         #             ^^^^^                        kind
         #                  ^^^                     name
-        #                                    ^^^   overload
+        #                                    ^^^   overloading
         #
-        type loc = Location[:keyword | :name, :kind | :overload | :visibility]
+        type loc = Location[:keyword | :name, :kind | :overloading | :visibility]
 
         attr_reader name: Symbol
         attr_reader kind: kind
-        attr_reader types: Array[MethodType]
+        attr_reader overloads: Array[Overload]
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
-        attr_reader overload: bool
+        attr_reader overloading: bool
         attr_reader visibility: visibility?
 
-        def initialize: (name: Symbol, kind: kind, types: Array[MethodType], annotations: Array[Annotation], location: loc?, comment: Comment?, overload: boolish, ?visibility: visibility?) -> void
+        def initialize: (name: Symbol, kind: kind, overloads: Array[Overload], annotations: Array[Annotation], location: loc?, comment: Comment?, overloading: bool, visibility: visibility?) -> void
 
         include _HashEqual
         include _ToJson
 
+        # Returns true if the `def` is to define instance method
         def instance?: () -> bool
 
+        # Returns true if the `def` is to define singleton method
         def singleton?: () -> bool
 
-        def overload?: () -> bool
+        # Returns true if the `def` is overloading (== with `...`)
+        #
+        def overloading?: () -> bool
 
-        def update: (?name: Symbol, ?kind: kind, ?types: Array[MethodType], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?overload: boolish, ?visibility: visibility?) -> MethodDefinition
+        def update: (?name: Symbol, ?kind: kind, ?overloads: Array[Overload], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?overloading: bool, ?visibility: visibility?) -> MethodDefinition
       end
 
       module Var
@@ -98,8 +122,7 @@ module RBS
         # include Array[String]
         # ^^^^^^^                keyword
         #         ^^^^^          name
-        #              ^         arg_open
-        #                     ^  arg_close
+        #              ^^^^^^^^  args
         #
         type loc = Location[:name | :keyword, :args]
 

data/sig/method_types.rbs

@@ -14,11 +14,11 @@ module RBS
     type loc = def_loc | attr_loc
 
     attr_reader type_params: Array[AST::TypeParam]
-    attr_reader type: Types::Function
+    attr_reader type: Types::function
     attr_reader block: Types::Block?
     attr_reader location: loc?
 
-    def initialize: (type_params: Array[AST::TypeParam], type: Types::Function, block: Types::Block?, location: loc?) -> void
+    def initialize: (type_params: Array[AST::TypeParam], type: Types::function, block: Types::Block?, location: loc?) -> void
 
     def ==: (untyped other) -> bool
 
@@ -29,7 +29,7 @@ module RBS
     #
     def sub: (Substitution) -> MethodType
 
-    def update: (?type_params: Array[AST::TypeParam], ?type: Types::Function, ?block: Types::Block?, ?location: loc?) -> MethodType
+    def update: (?type_params: Array[AST::TypeParam], ?type: Types::function, ?block: Types::Block?, ?location: loc?) -> MethodType
 
     def free_variables: (?Set[Symbol] set) -> Set[Symbol]
 
@@ -40,7 +40,7 @@ module RBS
     #
     def map_type: () { (Types::t) -> Types::t } -> MethodType
 
-    def map_type_bound: () { (AST::TypeParam::bound) -> AST::TypeParam::bound } -> MethodType
+    def map_type_bound: () { (Types::t) -> Types::t } -> MethodType
 
     def each_type: () { (Types::t) -> void } -> void
                  | () -> Enumerator[Types::t, void]
@@ -48,5 +48,11 @@ module RBS
     def to_s: () -> String
 
     def type_param_names: () -> Array[Symbol]
+
+    def has_self_type?: () -> bool
+
+    def has_classish_type?: () -> bool
+
+    def with_nonreturn_void?: () -> bool
   end
 end

data/sig/namespace.rbs

@@ -141,7 +141,6 @@ module RBS
 end
 
 module Kernel
-  # Parses given string and returns Namespace.
-  #
-  def Namespace: (String) -> RBS::Namespace
+  # Deprecated: Use `RBS::Namespace.parse` instead
+  %a{steep:deprecated} def Namespace: (String) -> RBS::Namespace
 end

data/sig/parser.rbs

@@ -1,43 +1,80 @@
 module RBS
   class Parser
+    # Result of `Parser.lex`
+    class LexResult
+      attr_reader buffer: Buffer
+      attr_reader value: Array[Token]
+
+      def initialize: (buffer: Buffer, value: Array[Token]) -> void
+    end
+
+    # Represents a token per result of `Parser.lex`.
+    class Token
+      attr_reader type: Symbol
+      attr_reader location: Location[untyped, untyped]
+
+      def initialize: (type: Symbol, location: Location[untyped, untyped]) -> void
+      def value: () -> String
+      def comment?: () -> bool
+    end
+
     # Parse a method type and return it
     #
-    # When `pos` keyword is specified, skips the first `pos` characters from the input.
-    # If no token is left in the input, it returns `nil`.
+    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
     #
     # ```ruby
+    # RBS::Parser.parse_method_type("() -> void")                                # => `() -> void`
     # RBS::Parser.parse_method_type("() -> void", range: 0...)                   # => `() -> void`
     # RBS::Parser.parse_method_type("() -> void () -> String", range: 11...)     # => `() -> String`
     # RBS::Parser.parse_method_type("() -> void () -> String", range: 23...)     # => nil
     # ```
     #
-    # `line` and `column` is deprecated and are ignored.
+    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
+    # (Defaults to `false`.)
+    #
+    # ```ruby
+    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: false)    # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: true)     # => Raises an error
+    #
+    # RBS::Parser.parse_method_type("", require_eof: true)                            # => nil
+    # ```
     #
-    def self.parse_method_type: (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol]) -> MethodType?
-                              | (Buffer | String, ?line: top, ?column: top, ?variables: Array[Symbol]) -> MethodType
+    def self.parse_method_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> MethodType?
 
     # Parse a type and return it
     #
-    # When `pos` keyword is specified, skips the first `pos` characters from the input.
-    # If no token is left in the input, it returns `nil`.
+    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
     #
     # ```ruby
+    # RBS::Parser.parse_type("String")                          # => `String`
     # RBS::Parser.parse_type("String", range: 0...)             # => `String`
     # RBS::Parser.parse_type("String Integer", pos: 7...)       # => `Integer`
     # RBS::Parser.parse_type("String Integer", pos: 14...)      # => nil
     # ```
     #
-    # `line` and `column` is deprecated and are ignored.
+    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
+    # (Defaults to `false`.)
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("String untyped", require_eof: false)    # => `String`
+    # RBS::Parser.parse_type("String untyped", require_eof: true)     # => Raises an error
+    #
+    # RBS::Parser.parse_type("", require_eof: true)                   # => nil
+    # ```
     #
-    def self.parse_type: (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol]) -> Types::t?
-                       | (Buffer | String, ?line: top, ?column: top, ?variables: Array[Symbol]) -> Types::t
+    def self.parse_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> Types::t?
 
     # Parse whole RBS file and return an array of declarations
     #
-    # `line` and `column` is deprecated and are ignored.
+    def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
+
+    # Parse whole RBS file and return result.
     #
-    def self.parse_signature: (Buffer | String) -> Array[AST::Declarations::t]
-                            | (Buffer | String, ?line: top, ?column: top) -> Array[AST::Declarations::t]
+    # ```ruby
+    # RBS::Parser.lex("# Comment\nmodule A\nend\n").value.map(&:type)
+    # # => [:tLINECOMMENT, :kMODULE, :tUIDENT, :kEND, :pEOF]
+    # ```
+    def self.lex: (Buffer | String) -> LexResult
 
     KEYWORDS: Hash[String, bot]
 
@@ -45,11 +82,13 @@ module RBS
 
     def self.buffer: (String | Buffer source) -> Buffer
 
-    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, boolish eof) -> Types::t?
+    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> Types::t?
+
+    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
 
-    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, boolish eof) -> MethodType?
+    def self._parse_signature: (Buffer, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
-    def self._parse_signature: (Buffer, Integer end_pos) -> Array[AST::Declarations::t]
+    def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]
 
     class LocatedValue
     end

data/sig/prototype/helpers.rbs

@@ -13,6 +13,10 @@ module RBS
 
       def keyword_hash?: (node) -> bool
 
+      # Returns a symbol if the node is a symbol literal node
+      # 
+      def symbol_literal_node?: (node) -> Symbol?
+
       def args_from_node: (node?) -> Array[untyped]
 
       def untyped: () -> Types::Bases::Any

data/sig/prototype/node_usage.rbs

@@ -0,0 +1,20 @@
+module RBS
+  module Prototype
+    class NodeUsage
+      include Helpers
+      
+      type node = RubyVM::AbstractSyntaxTree::Node
+
+      attr_reader node: node
+
+      attr_reader conditional_nodes: Set[node]
+
+      def initialize: (node) -> void
+
+      def calculate: (node, conditional: bool) -> void
+
+      def each_conditional_node: () { (node) -> void } -> void
+                               | () -> Enumerator[node, void]
+    end
+  end
+end

data/sig/prototype/rb.rbs

@@ -12,12 +12,18 @@ module RBS
 
         attr_accessor namespace: Namespace
 
-        def initialize: (module_function: bool, singleton: bool, namespace: Namespace) -> void
+        attr_accessor in_def: bool
+
+        def initialize: (module_function: bool, singleton: bool, namespace: Namespace, in_def: bool) -> void
 
         def method_kind: () -> method_kind
 
         def attribute_kind: () -> (:singleton | :instance)
 
+        def enter_namespace: (Namespace) -> Context
+
+        def update: (?module_function: bool, ?singleton: bool, ?in_def: bool) -> Context
+
         def self.initial: (?namespace: Namespace) -> Context
       end
 
@@ -38,7 +44,7 @@ module RBS
       # Returns a type name that represents the name of the constant.
       # `node` must be _constant_ node, `CONST`, `COLON2`, or `COLON3` node.
       #
-      def const_to_name!: (RubyVM::AbstractSyntaxTree::Node node) -> TypeName
+      def const_to_name!: (RubyVM::AbstractSyntaxTree::Node node, ?context: Context?) -> TypeName
 
       # Returns a type name that represents the name of the constant.
       # `node` can be `SELF` for `extend self` pattern.
@@ -83,6 +89,8 @@ module RBS
       def is_accessibility?: (decl) -> bool
 
       def find_def_index_by_name: (Array[decl] decls, Symbol name) -> [Integer, AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrWriter]?
+
+      def sort_members!: (Array[decl] decls) -> void
     end
   end
 end

data/sig/prototype/rbi.rbs

@@ -1,6 +1,8 @@
 module RBS
   module Prototype
     class RBI
+      include Helpers
+      
       attr_reader decls: Array[AST::Declarations::t]
 
       type module_decl = AST::Declarations::Class | AST::Declarations::Module

data/sig/prototype/runtime.rbs

@@ -0,0 +1,182 @@
+module RBS
+  module Prototype
+    class Runtime
+      module Reflection
+        self.@object_class: UnboundMethod
+        def self.object_class: (Module value) -> Class
+
+        self.@constants_of: UnboundMethod
+        def self.constants_of: (Module mod, ?bool inherit) -> Array[Symbol]
+      end
+
+      module Helpers
+        @module_name_method: UnboundMethod
+        @untyped: Types::Bases::Any
+
+        private
+
+        def const_name: (Module const) -> String?
+
+        def const_name!: (Module const) -> String
+
+        # Returns the exact name & not compactly declared name
+        def only_name: (Module mod) -> String
+
+        def to_type_name: (String name, ?full_name: bool) -> TypeName
+
+        def untyped: () -> Types::Bases::Any
+      end
+
+      class ValueObjectBase
+        include Helpers
+
+        # @target_class stores the singleton object of `Data` or `Struct` subclass
+        @target_class: untyped
+
+        def build_decl: () -> AST::Declarations::Class
+
+        private
+
+        def build_member_accessors: (untyped ast_members_class) -> untyped
+
+        def build_s_members: () -> Array[AST::Members::MethodDefinition]
+
+        def build_super_class: () -> AST::Declarations::Class::Super
+
+        def add_decl_members: (AST::Declarations::Class) -> void
+
+        def initialize: (Class target_class) -> void
+      end
+
+      class StructGenerator < ValueObjectBase
+        def self.generatable?: (Class target) -> bool
+
+        private
+
+        def add_decl_members: (AST::Declarations::Class decl) -> void
+
+        def build_overload_for_keyword_arguments: () -> AST::Members::MethodDefinition::Overload
+
+        def build_overload_for_positional_arguments: () -> AST::Members::MethodDefinition::Overload
+
+        def build_s_keyword_init_p: () -> Array[AST::Members::MethodDefinition]
+
+        def build_s_new: () -> Array[AST::Members::MethodDefinition]
+
+        def build_super_class: () -> AST::Declarations::Class::Super
+
+        CAN_CALL_KEYWORD_INIT_P: bool
+      end
+
+      class DataGenerator < ValueObjectBase
+        def self.generatable?: (Class target) -> bool
+
+        private
+
+        def add_decl_members: (AST::Declarations::Class decl) -> void
+
+        def build_s_new: () -> Array[AST::Members::MethodDefinition]
+
+        def build_super_class: () -> AST::Declarations::Class::Super
+      end
+
+      class Todo
+        @builder: DefinitionBuilder
+
+        @mixin_decls_cache: Hash[TypeName, Array[untyped]]
+
+        def initialize: (builder: DefinitionBuilder) -> void
+
+        def skip_mixin?: (type_name: TypeName, module_name: TypeName, mixin_class: mixin_class) -> bool
+
+        def skip_singleton_method?: (module_name: TypeName, method: UnboundMethod, accessibility: Definition::accessibility) -> bool
+
+        def skip_instance_method?: (module_name: TypeName, method: UnboundMethod, accessibility: Definition::accessibility) -> bool
+
+        def skip_constant?: (module_name: String, name: Symbol) -> bool
+
+        private def mixin_decls: (TypeName type_name) -> Array[AST::Members::Include | AST::Members::Extend | AST::Members::Prepend]
+      end
+
+      type mixin_class = singleton(AST::Members::Include) | singleton(AST::Members::Prepend) | singleton(AST::Members::Extend)
+
+      @decls: Array[AST::Declarations::t]?
+
+      @modules: Hash[String, Module]
+
+      @builder: DefinitionBuilder
+
+      @module_name_method: UnboundMethod
+      @object_class: UnboundMethod
+
+      @todo_object: Todo?
+
+      include Helpers
+
+      attr_reader patterns: Array[String]
+
+      attr_reader env: Environment
+
+      attr_reader merge: bool
+
+      attr_reader todo: bool
+
+      attr_accessor outline: bool
+
+      attr_reader owners_included: Array[Module]
+
+      def initialize: (patterns: Array[String], env: Environment, merge: bool, ?todo: bool, ?owners_included: Array[Symbol]) -> void
+
+      def target?: (Module const) -> bool
+
+      def todo_object: () -> Todo?
+
+      def builder: () -> DefinitionBuilder
+
+      def parse: (String file) -> void
+
+      def decls: () -> Array[AST::Declarations::t]
+
+      def each_mixined_module: (TypeName type_name, Module mod) { (TypeName, TypeName, mixin_class) -> void } -> void
+
+      def each_mixined_module_one: (TypeName type_name, Module mod) { (TypeName, TypeName, bool) -> void } -> void
+
+      def method_type: (UnboundMethod method) -> MethodType
+
+      def merge_rbs: [A] (TypeName module_name, Array[AST::Declarations::Class::member] members, singleton: Symbol) { () -> A } -> A?
+                   | [A] (TypeName module_name, Array[AST::Declarations::Class::member] members, instance: Symbol) { () -> A } -> A?
+
+      def target_method?: (Module mod, instance: Symbol) -> bool
+                        | (Module mod, singleton: Symbol) -> bool
+
+      def generate_methods: (Module mod, TypeName module_name, Array[AST::Declarations::Class::member] members) -> void
+
+      def generate_constants: (Module mod, Array[AST::Declarations::Class::member] decls) -> void
+
+      def generate_super_class: (Class mod) -> AST::Declarations::Class::Super?
+
+      def generate_class: (Class mod) -> void
+
+      def generate_module: (Module mod) -> void
+
+      def generate_mixin: (Module mod, AST::Declarations::Class | AST::Declarations::Module, TypeName, TypeName) -> void
+
+      # Generate/find outer module declarations
+      # This is broken down into another method to comply with `DRY`
+      # This generates/finds declarations in nested form & returns the last array of declarations
+      def ensure_outer_module_declarations: (Module mod) -> Array[AST::Declarations::Class::member]
+
+      def object_class: (untyped) -> untyped
+
+      def type_args: (TypeName type_name) -> Array[Types::t]
+
+      def block_from_ast_of: (UnboundMethod method) -> Types::Block?
+
+      def block_from_body: (RubyVM::AbstractSyntaxTree::Node) -> Types::Block?
+
+      def can_alias?: (Module, UnboundMethod) -> bool
+
+      def type_params: (Module) -> Array[AST::TypeParam]
+    end
+  end
+end

data/sig/rbs.rbs

@@ -5,7 +5,7 @@ module RBS
 
   def self.logger_level=: (Integer?) -> Integer?
 
-  def self.logger_output: () -> IO
+  %a{pure} def self.logger_output: () -> IO?
 
   def self.logger_output=: (IO) -> IO
 

data/sig/rdoc/rbs.rbs

@@ -8,6 +8,10 @@ end
 module RBS
   module RDocPlugin
     class Parser
+      @top_level: RDoc::TopLevel
+
+      @content: String
+
       type allowed_decls = RBS::AST::Declarations::Class
                          | RBS::AST::Declarations::Module
                          | RBS::AST::Declarations::Constant

data/sig/repository.rbs

@@ -3,12 +3,14 @@ module RBS
   #
   # A repository object can handle multiple repository roots.
   #
-  #   repo = RBS::Repository.new()
-  #   repo.add(Pathname("vendor/rbs/gem-rbs"))
-  #   repo.add(Pathname("vendor/rbs/internal-rbs"))
-  #   repo.add(Pathname("vendor/rbs/definitely-rbs"))
+  # ```ruby
+  # repo = RBS::Repository.new()
+  # repo.add(Pathname("vendor/rbs/gem-rbs"))
+  # repo.add(Pathname("vendor/rbs/internal-rbs"))
+  # repo.add(Pathname("vendor/rbs/definitely-rbs"))
   #
-  #   repo.lookup("minitest", "2.1.3") => Pathname or nil
+  # repo.lookup("minitest", "2.1.3") # => Pathname or nil
+  # ```
   #
   # If one gem version can resolve to several directories, the last added dir wins.
   #

data/sig/resolver/constant_resolver.rbs

@@ -6,8 +6,8 @@ module RBS
       # ```rb
       # table = RBS::ConstantResolver::Table.new(env)
       #
-      # table.children(TypeName("::Object"))                # -> { ... }  Returns a hash of name and constants.
-      # table.children(TypeName("::File::PATH_SEPARATOR"))  # -> nil      Returns nil because the constant is not a module.
+      # table.children(TypeName.parse("::Object"))                # -> { ... }  Returns a hash of name and constants.
+      # table.children(TypeName.parse("::File::PATH_SEPARATOR"))  # -> nil      Returns nil because the constant is not a module.
       #
       # table.toplevel                                      # -> { ... }  Returns a hash of top level constants.
       # ```
@@ -37,7 +37,7 @@ module RBS
 
         def constant_of_module: (TypeName name, Environment::ClassEntry | Environment::ModuleEntry) -> Constant
 
-        def constant_of_constant: (TypeName name, Environment::SingleEntry[TypeName, AST::Declarations::Constant]) -> Constant
+        def constant_of_constant: (TypeName name, Environment::ConstantEntry) -> Constant
       end
 
       attr_reader builder: DefinitionBuilder
@@ -65,7 +65,6 @@ module RBS
       #    ^  <- constant_name
       # ```
       #
-      # Find the
       def resolve_child: (TypeName module_name, Symbol constant_name) -> Constant?
 
       # Returns the table of all constants accessible with `::` (colon2) operator.

data/sig/resolver/context.rbs

@@ -9,7 +9,7 @@ module RBS
     #
     # Note that the `TypeName` must be an absolute type name.
     #
-    # The following Ruby code has context of `[[nil, TypeName("::Foo")], false]` where
+    # The following Ruby code has context of `[[nil, TypeName.parse("::Foo")], false]` where
     #
     # * `Foo` is a class defined in RBS file
     # * `Bar` is not defined in RBS files

data/sig/resolver/type_name_resolver.rbs

@@ -17,6 +17,8 @@ module RBS
 
       private
 
+      attr_reader env: Environment
+
       attr_reader all_names: Set[TypeName]
 
       attr_reader cache: Hash[query, TypeName?]
@@ -25,7 +27,9 @@ module RBS
 
       def try_cache: (query) { () -> TypeName? } -> TypeName?
 
-      def resolve_in: (TypeName, context) -> TypeName?
+      def resolve_in: (Symbol, context) -> TypeName?
+
+      def partition: (TypeName) -> [Symbol, TypeName?]
     end
   end
 end

data/sig/shims/bundler.rbs

@@ -0,0 +1,38 @@
+module Bundler
+  class LockfileParser
+    def initialize: (String) -> void
+
+    def specs: () -> Array[LazySpecification]
+  end
+
+  class LazySpecification
+    def name: () -> String
+
+    def version: () -> String
+
+    def dependencies: () -> Array[Gem::Dependency]
+  end
+
+  class Dependency < Gem::Dependency
+    attr_reader autorequire: Array[String]?
+
+    attr_reader source: untyped
+  end
+
+  class Definition
+    def lockfile: () -> Pathname
+
+    def locked_gems: () -> LockfileParser
+
+    def dependencies: () -> Array[Dependency]
+  end
+
+  def self.default_lockfile: () -> Pathname
+
+  def self.definition: () -> Definition
+
+  module Source
+    class Gemspec
+    end
+  end
+end

data/sig/shims/rubygems.rbs

@@ -0,0 +1,19 @@
+module Gem
+  class Specification
+    attr_reader version (): Version
+
+    attr_reader gem_dir (): String
+
+    def self.find_by_name: (String name, *String requirements) -> instance
+
+    def dependencies: () -> Array[Dependency]
+  end
+
+  class Dependency
+    def name: () -> String
+  end
+
+  module ::Kernel
+    def self?.gem: (String, *String) -> void
+  end
+end