rbs 3.6.1 → 3.9.5

data/lib/rdoc_plugin/parser.rb

@@ -108,7 +108,7 @@ module RBS
 
       def parse_include_decl(decl:, context:, outer_name: nil)
         name = decl.name.to_s
-        outer_names = outer_name ? outer_name.to_s.split("::") : []
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
         qualified_name = ''
         outer_names.each do |namespace|
           qualified_name += namespace
@@ -124,7 +124,7 @@ module RBS
 
       def parse_extend_decl(decl:, context:, outer_name: nil)
         name = decl.name.to_s
-        outer_names = outer_name ? outer_name.to_s.split("::") : []
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
         qualified_name = ''
         outer_names.each do |namespace|
           qualified_name += namespace

data/rbs.gemspec

@@ -30,16 +30,20 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject do |f|
       [
-        %r{^(test|spec|features|bin|steep|benchmark)/},
+        %r{^(test|spec|features|bin|steep|benchmark|templates)/},
         /Gemfile/
       ].any? {|r| f.match(r) }
     end
   end
   spec.extensions = %w{ext/rbs_extension/extconf.rb}
 
+  if false
+    spec.required_ruby_version = ">= 3.3"
+  end
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 3.0"
+  spec.required_ruby_version = ">= 3.1"
   spec.add_dependency "logger"
 end

data/sig/ancestor_graph.rbs

@@ -1,14 +1,14 @@
 module RBS
-  # AncestorGraph is a utility class that helps iterating through ancestors and decendants of a class/module
+  # AncestorGraph is a utility class that helps iterating through ancestors and descendants of a class/module
   #
   # ```ruby
   # graph = AncestorGraph.new(env: env, ancestor_builder: ancestor_builder)
   #
-  # graph.each_parent(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
-  # graph.each_ancestor(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
+  # graph.each_parent(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_ancestor(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
   #
-  # graph.each_child(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
-  # graph.each_descendant(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
+  # graph.each_child(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
+  # graph.each_descendant(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
   # ```
   #
   # Note that the class works for class/module declarations.

data/sig/annotate/rdoc_source.rbs

@@ -25,6 +25,8 @@ module RBS
                      | (TypeName, singleton_method: Symbol) -> Array[RDoc::AnyMethod]?
 
       def find_attribute: (TypeName, Symbol, singleton: bool) -> Array[RDoc::Attr]?
+
+      def class_docs: (TypeName) -> Array[::RDoc::Markup::Document | ::RDoc::Comment | ::String]?
     end
   end
 end

data/sig/cli.rbs

@@ -80,6 +80,8 @@ module RBS
 
     def run_subtract: (Array[String], top) -> void
 
+    def run_diff: (Array[String], LibraryOptions) -> void
+
     def test_opt: (LibraryOptions) -> String?
 
     def collection_options: (Array[String]) -> OptionParser

data/sig/collection/config/lockfile_generator.rbs

@@ -2,6 +2,10 @@ module RBS
   module Collection
     class Config
       class LockfileGenerator
+        # Name of stdlibs that was rbs-bundled stdlib but is now a gem.
+        #
+        ALUMNI_STDLIBS: Hash[String, String?]
+
         class GemfileLockMismatchError < StandardError
           @expected: Pathname
 
@@ -43,7 +47,11 @@ module RBS
         #
         def assign_gem: (name: String, version: String?, ?skip: bool) -> void
 
-        def assign_stdlib: (name: String, from_gem: String?) -> void
+        # Assign a gem from stdlib to lockfile
+        #
+        # `from_gem` is a String when the stdlib is assigned through the `dependencies:` in `manifest.yaml` of a gem.
+        #
+        def assign_stdlib: (name: String, ?from_gem: String) -> void
 
         # Find a source of a gem from ones registered in `config.sources`
         #

data/sig/declarations.rbs

@@ -205,8 +205,10 @@ module RBS
         attr_reader type: Types::t
         attr_reader location: loc?
         attr_reader comment: Comment?
+        attr_reader annotations: Array[Annotation]
 
-        def initialize: (name: TypeName, type: Types::t, location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type: Types::t, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (name: TypeName, type: Types::t, location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -223,8 +225,10 @@ module RBS
         attr_reader type: Types::t
         attr_reader location: loc?
         attr_reader comment: Comment?
+        attr_reader annotations: Array[Annotation]
 
-        def initialize: (name: Symbol, type: Types::t, location: loc?, comment: Comment?) -> void
+        def initialize: (name: Symbol, type: Types::t, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (name: Symbol, type: Types::t, location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -250,7 +254,10 @@ module RBS
 
         attr_reader comment: Comment?
 
-        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
+        attr_reader annotations: Array[Annotation]
+
+        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
 
         include _HashEqual
       end

data/sig/definition.rbs

@@ -6,8 +6,15 @@ module RBS
       attr_reader parent_variable: Variable?
       attr_reader type: Types::t
       attr_reader declared_in: TypeName
+      type source = AST::Members::AttrAccessor
+                  | AST::Members::AttrReader
+                  | AST::Members::AttrWriter
+                  | AST::Members::InstanceVariable
+                  | AST::Members::ClassVariable
+                  | AST::Members::ClassInstanceVariable
+      attr_reader source: source
 
-      def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName) -> void
+      def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName, source: source) -> void
 
       def sub: (Substitution) -> Variable
     end
@@ -21,34 +28,94 @@ module RBS
         attr_reader defined_in: TypeName
         attr_reader implemented_in: TypeName?
 
-        def initialize: (type: MethodType, member: method_member, defined_in: TypeName, implemented_in: TypeName?) -> void
+        # Annotations given to the method definition syntax
+        #
+        # If the method have multiple syntaxes, union of the annotations to the member will be included, without dedup.
+        #
+        # The value should be updated during setup.
+        #
+        attr_reader member_annotations: Array[AST::Annotation]
+
+        # Annotations given to the overload associated to the method type
+        #
+        # The value should be updated during setup.
+        #
+        attr_reader overload_annotations: Array[AST::Annotation]
+
+        # Always returns an empty array
+        %a{deprecated} attr_reader annotations: Array[AST::Annotation]
+
+        # `overload_annotations` is ignored.
+        def initialize: (
+            type: MethodType,
+            member: method_member,
+            defined_in: TypeName,
+            implemented_in: TypeName?
+          ) -> void
+        | %a{deprecated} (
+            type: MethodType,
+            member: method_member,
+            defined_in: TypeName,
+            implemented_in: TypeName?,
+            overload_annotations: nil
+          ) -> void
 
         def comment: () -> AST::Comment?
 
-        def annotations: () -> Array[AST::Annotation]
-
         def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName, ?implemented_in: TypeName?) -> TypeDef
 
         def overload?: () -> bool
+
+        # Yields member and overload annotations, without dedup
+        #
+        # Member annotation yields first.
+        #
+        def each_annotation: () { (AST::Annotation) -> void } -> void
+                           | () -> Enumerator[AST::Annotation]
       end
 
       attr_reader super_method: Method?
       attr_reader defs: Array[TypeDef]
       attr_reader accessibility: accessibility
-      attr_reader extra_annotations: Array[AST::Annotation]
+
       attr_reader defined_in: TypeName?
       attr_reader implemented_in: TypeName?
       attr_reader method_types: Array[MethodType]
       attr_reader comments: Array[AST::Comment]
-      attr_reader annotations: Array[AST::Annotation]
+
       attr_reader members: Array[method_member]
+
+      # The original method when the method is defined with `alias` syntax
       attr_reader alias_of: Method?
 
-      def initialize: (super_method: Method?,
-                       defs: Array[TypeDef],
-                       accessibility: accessibility,
-                       alias_of: Method?,
-                       ?annotations: Array[AST::Annotation]) -> void
+      # Present if the method is defined with `alias` syntax
+      attr_reader alias_member: AST::Members::Alias?
+
+      # Unused, always returns empty array
+      %a{deprecated} attr_reader extra_annotations: Array[AST::Annotation]
+
+      # Union of annotations given to `def`s and `alias`, not contains annotations given to each overload
+      #
+      # The elements will be updated during `Method` object setup.
+      #
+      attr_reader annotations: Array[AST::Annotation]
+
+      # Note that the annotations given through `annotations:` keyword is ignored.
+      #
+      def initialize: (
+          super_method: Method?,
+          defs: Array[TypeDef],
+          accessibility: accessibility,
+          alias_of: Method?,
+          alias_member: AST::Members::Alias?
+        ) -> void
+      | %a{deprecated} (
+          super_method: Method?,
+          defs: Array[TypeDef],
+          accessibility: accessibility,
+          alias_of: Method?,
+          annotations: Array[AST::Annotation]
+        ) -> void
 
       def public?: () -> bool
 
@@ -75,7 +142,8 @@ module RBS
         ?defs: Array[TypeDef],
         ?accessibility: accessibility,
         ?alias_of: Method?,
-        ?annotations: Array[AST::Annotation]
+        ?annotations: Array[AST::Annotation],
+        ?alias_member: AST::Members::Alias?
       ) -> Method
     end
 

data/sig/definition_builder.rbs

@@ -105,7 +105,15 @@ module RBS
 
     def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location[untyped, untyped]?
 
-    def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void
+    def validate_variable: (Definition::Variable) -> void
+
+    def insert_variable: (
+      TypeName,
+      Hash[Symbol, Definition::Variable],
+      name: Symbol,
+      type: Types::t,
+      source: Definition::Variable::source
+    ) -> void
 
     # Add method definition to `methods`, which will be merged to `class_definition` after defining all methods at this *level* -- class, module, or interface
     #
@@ -142,11 +150,17 @@ module RBS
       Hash[Symbol, Definition::Method]? self_type_methods,
     ) -> void
 
-    # Updates `definition` with methods and variables of `type_name` that can be a module or a class
+    # Updates `definition` with methods and instance variables of `type_name` that can be a module or a class
     #
     # It processes includes and prepends recursively.
+    # If `define_class_vars:` is falsy, it skips inserting class variables.
     #
-    def define_instance: (Definition definition, TypeName type_name, Substitution subst) -> void
+    def define_instance: (
+      Definition definition,
+      TypeName type_name,
+      Substitution subst,
+      define_class_vars: bool
+    ) -> void
 
     # Updates `definition` with methods defined in an interface `type_name`
     #
@@ -157,7 +171,7 @@ module RBS
     # Returns a substitution that corresponds to type application
     #
     # ```
-    # tapp_subst(`::Array`, [`::Integer`]) # => Subsitution.build([:Elem], [`::Integer`])
+    # tapp_subst(`::Array`, [`::Integer`]) # => Substitution.build([:Elem], [`::Integer`])
     # ```
     #
     def tapp_subst: (TypeName, Array[Types::t]) -> Substitution

data/sig/directives.rbs

@@ -1,7 +1,7 @@
 module RBS
   module AST
     module Directives
-      type t = Use
+      type t = Use | ResolveTypeNames
 
       class Base
       end
@@ -56,6 +56,22 @@ module RBS
 
         def initialize: (clauses: Array[clause], location: loc?) -> void
       end
+
+      class ResolveTypeNames < Base
+        # ```
+        # # resolve-type-names: false
+        #   ^^^^^^^^^^^^^^^^^^          keyword
+        #                     ^         colon
+        #                       ^^^^^   value
+        # ```
+        type loc = Location[:keyword | :colon | :value, bot]
+
+        attr_reader location: loc?
+
+        attr_reader value: bool
+
+        def initialize: (value: bool, location: loc?) -> void
+      end
     end
   end
 end

data/sig/environment.rbs

@@ -141,6 +141,8 @@ module RBS
     #
     def resolve_type_names: (?only: Set[AST::Declarations::t]?) -> Environment
 
+    def resolve_signature: (Resolver::TypeNameResolver, UseMap::Table, Array[AST::Directives::t], Array[AST::Declarations::t], ?only: Set[AST::Declarations::t]?) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+
     def inspect: () -> String
 
     def buffers: () -> Array[Buffer]
@@ -233,7 +235,7 @@ module RBS
     def normalize_type_name?: (TypeName) -> (TypeName | nil | false)
 
     # Normalize the type name or raises an error
-    # 
+    #
     def normalize_type_name!: (TypeName) -> TypeName
 
     # Returns a normalized module/class name or a type name with a normalized namespace

data/sig/errors.rbs

@@ -182,6 +182,25 @@ module RBS
     def location: () -> AST::Members::Mixin::loc?
   end
 
+  class VariableDuplicationError < DefinitionError
+    include DetailedMessageable
+
+    attr_reader type_name: TypeName
+    attr_reader variable_name: Symbol
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (type_name: TypeName, variable_name: Symbol, location: Location[untyped, untyped]?) -> void
+    def kind: () -> String
+  end
+
+  class InstanceVariableDuplicationError < VariableDuplicationError
+    def kind: () -> String
+  end
+
+  class ClassInstanceVariableDuplicationError < VariableDuplicationError
+    def kind: () -> String
+  end
+
   # The `alias` member declares an alias from unknown method
   #
   class UnknownMethodAliasError < DefinitionError

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{deprecated} def Namespace: (String) -> RBS::Namespace
 end

data/sig/parser.rbs

@@ -68,6 +68,10 @@ module RBS
     #
     def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
 
+    # Returns the magic comment from the buffer
+    #
+    def self.magic_comment: (Buffer) -> AST::Directives::ResolveTypeNames?
+
     # Parse whole RBS file and return result.
     #
     # ```ruby
@@ -86,7 +90,7 @@ module RBS
 
     def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
 
-    def self._parse_signature: (Buffer, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+    def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
     def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]
 

data/sig/prototype/rb.rbs

@@ -44,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.

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.
       # ```

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/subtractor.rbs

@@ -24,7 +24,7 @@ module RBS
 
     private def mixin_exist?: (TypeName owner, AST::Members::Include | AST::Members::Extend | AST::Members::Prepend, context: Resolver::context) -> boolish
 
-    private def filter_redundunt_access_modifiers: (Array[AST::Declarations::t | AST::Members::t]) -> Array[AST::Declarations::t | AST::Members::t]
+    private def filter_redundant_access_modifiers: (Array[AST::Declarations::t | AST::Members::t]) -> Array[AST::Declarations::t | AST::Members::t]
 
     private def access_modifier?: (AST::Declarations::t | AST::Members::t?) -> bool
 

data/sig/test/type_check.rbs

@@ -7,12 +7,12 @@ module RBS
       #
       # Returns an array with detected errors.
       #
-      def method_call: (Symbol, MethodType, CallTrace, errors: Array[Errors::t]) -> Array[Errors::t]
+      def method_call: (Symbol, MethodType, CallTrace, errors: Array[Errors::t], ?annotations: Array[AST::Annotation]) -> Array[Errors::t]
 
       # Test if given `value` is compatible to type
       #
       # Returns `true` if the value has the type.
-      # 
+      #
       def value: (untyped value, Types::t) -> bool
     end
   end

data/sig/type_alias_dependency.rbs

@@ -1,5 +1,5 @@
 module RBS
-  # TypeAliasDependency calculates the dependnecies between type aliases
+  # TypeAliasDependency calculates the dependencies between type aliases
   #
   # The dependencies are normalized automatically.
   #
@@ -12,7 +12,7 @@ module RBS
     #
     attr_reader direct_dependencies: Hash[TypeName, Set[TypeName]]
 
-    # A hash table from type alias name to a hash name with keys of transitive dependnecies
+    # A hash table from type alias name to a hash name with keys of transitive dependencies
     #
     # The source type name and dependencies are normalized.
     #

data/sig/type_alias_regularity.rbs

@@ -20,9 +20,9 @@ module RBS
   # ```rb
   # validator = RBS::TypeAliasRegularity.validate(env: env)
   #
-  # validator.nonregular?(TypeName("::foo"))    # => nil
-  # validator.nonregular?(TypeName("::bar"))    # => nil
-  # validator.nonregular?(TypeName("::baz"))    # => TypeAliasRegularity::Diagnostic
+  # validator.nonregular?(TypeName.parse("::foo"))    # => nil
+  # validator.nonregular?(TypeName.parse("::bar"))    # => nil
+  # validator.nonregular?(TypeName.parse("::baz"))    # => TypeAliasRegularity::Diagnostic
   # ```
   #
   # A special case is when the type argument is `untyped`.
@@ -51,8 +51,8 @@ module RBS
     # The type `t` is nonregular because it contains `t[T?]` on it's right hand side.
     #
     # ```
-    # diagnostic = validator.nonregular?(TypeName("::t"))
-    # diagnostic.type_name         # => TypeName("::t")
+    # diagnostic = validator.nonregular?(TypeName.parse("::t"))
+    # diagnostic.type_name         # => TypeName.parse("::t")
     # diagnostic.nonregular_type   # => t[T?]
     # ```
     #
@@ -71,7 +71,7 @@ module RBS
     def initialize: (env: Environment) -> void
 
     # Returns `Diagnostic` instance if the alias type is nonregular.
-    # Regurns `nil` if the alias type is regular.
+    # Returns `nil` if the alias type is regular.
     #
     # Normalizes the given type name automatically.
     #

data/sig/type_param.rbs

@@ -26,7 +26,7 @@ module RBS
 
       attr_reader default_type: Types::t?
 
-      def initialize: (name: Symbol, variance: variance, upper_bound: Types::t?, location: loc?, ?default_type: Types::t?) -> void
+      def initialize: (name: Symbol, variance: variance, upper_bound: Types::t?, location: loc?, ?default_type: Types::t?, ?unchecked: bool) -> void
 
       include _ToJson
 
@@ -75,7 +75,7 @@ module RBS
 
       def to_s: () -> String
 
-      # Validates TypeParams if it refers another optiional type params
+      # Validates TypeParams if it refers another optional type params
       #
       # * Returns array of TypeParam objects that refers other optional type params
       # * Returns `nil` if all type params are valid
@@ -86,7 +86,7 @@ module RBS
       #
       def self.application: (Array[TypeParam], Array[Types::t]) -> Substitution?
 
-      # Returns an array of type args, that fills ommited types with the defaults
+      # Returns an array of type args, that fills omitted types with the defaults
       #
       # ```rbs
       # interface _Foo[T, S = untyped]
@@ -102,7 +102,7 @@ module RBS
       # _Foo[String, Integer, untyped] # => _Foo[String, Integer, untyped]  (Keeping extra args)
       # ```
       #
-      # Note that it allows iinvalid arities, returning the `args` immediately.
+      # Note that it allows invalid arities, returning the `args` immediately.
       #
       def self.normalize_args: (Array[TypeParam], Array[Types::t]) -> Array[Types::t]
     end

data/sig/typename.rbs

@@ -57,9 +57,9 @@ module RBS
     # Returns a new type name with a namespace appended to given namespace.
     #
     # ```rb
-    # TypeName("Hello").with_prefix(Namespace("World"))           # => World::Hello
-    # TypeName("Foo::Bar").with_prefix(Namespace("::Hello"))      # => ::Hello::Foo::Bar
-    # TypeName("::A::B").with_prefix(Namespace("C"))              # => ::A::B
+    # TypeName.parse("Hello").with_prefix(Namespace("World"))           # => World::Hello
+    # TypeName.parse("Foo::Bar").with_prefix(Namespace("::Hello"))      # => ::Hello::Foo::Bar
+    # TypeName.parse("::A::B").with_prefix(Namespace("C"))              # => ::A::B
     # ```
     #
     def with_prefix: (Namespace namespace) -> TypeName
@@ -67,10 +67,13 @@ module RBS
     def +: (TypeName) -> TypeName
 
     def split: () -> Array[Symbol]
+
+    # Returns type name with given string representation.
+    def self.parse: (String name) -> RBS::TypeName
   end
 end
 
 module Kernel
-  # Returns type name with given string representation.
-  def TypeName: (String name) -> RBS::TypeName
+  # Deprecated: Use `RBS::TypeName.parse` instead
+  %a{deprecated: Use `RBS::TypeName.parse` instead} def TypeName: (String name) -> RBS::TypeName
 end

data/sig/types.rbs

@@ -113,7 +113,7 @@ module RBS
       class Any < Base
         @string: String?
 
-        def todo!: () -> self
+        def initialize: (location: Location[bot, bot]?, ?todo: bool) -> void
       end
 
       class Nil < Base

data/sig/unit_test/spy.rbs

@@ -5,6 +5,8 @@ module RBS
                    | [T, S] (untyped object, Symbol method_name) { (WrapSpy[T], T) -> S } -> S
 
       class WrapSpy[T]
+        NO_RETURN: Object
+
         attr_accessor callback: ^(Test::CallTrace) -> void
 
         attr_reader object: T

data/sig/unit_test/type_assertions.rbs

@@ -104,6 +104,8 @@ module RBS
       #
       def class_class: () -> Class
 
+      def method_defs: (Symbol) -> Array[Definition::Method::TypeDef]
+
       def method_types: (Symbol) -> Array[MethodType]
 
       def allows_error: (*Exception) { () -> void } -> void

data/sig/use_map.rbs

@@ -3,7 +3,7 @@ module RBS
     # ```rb
     # map = UseMap.build(environment)
     #
-    # map.resolve?(TypeName("TN"))   # => nil or resolved type name
+    # map.resolve?(TypeName.parse("TN"))   # => nil or resolved type name
     # ```
     #
     class UseMap