rbs 3.6.1 → 3.9.5

data/lib/rbs/prototype/runtime.rb

@@ -48,7 +48,8 @@ module RBS
 
         def mixin_decls(type_name)
           type_name_absolute = type_name.absolute!
-          (@mixin_decls_cache ||= {}).fetch(type_name_absolute) do
+          @mixin_decls_cache ||= {} #: Hash[TypeName, Array[AST::Members::Mixin]]
+          @mixin_decls_cache.fetch(type_name_absolute) do
             @mixin_decls_cache[type_name_absolute] = @builder.env.class_decls[type_name_absolute].decls.flat_map do |d|
               d.decl.members.select { |m| m.kind_of?(AST::Members::Mixin) }
             end
@@ -249,6 +250,8 @@ module RBS
               method = builder.build_singleton(module_name.absolute!).methods[singleton]
               method_name = singleton
               kind = :singleton
+            else
+              raise
             end
 
             if method
@@ -448,9 +451,9 @@ module RBS
                      location: nil
                    )
                  when ARGF
-                   Types::ClassInstance.new(name: TypeName("::RBS::Unnamed::ARGFClass"), args: [], location: nil)
+                   Types::ClassInstance.new(name: TypeName.parse("::RBS::Unnamed::ARGFClass"), args: [], location: nil)
                  when ENV
-                   Types::ClassInstance.new(name: TypeName("::RBS::Unnamed::ENVClass"), args: [], location: nil)
+                   Types::ClassInstance.new(name: TypeName.parse("::RBS::Unnamed::ENVClass"), args: [], location: nil)
                  else
                    value_type_name = to_type_name(const_name!(Reflection.object_class(value)), full_name: true).absolute!
                    args = type_args(value_type_name)
@@ -461,6 +464,7 @@ module RBS
             name: to_type_name(name.to_s),
             type: type,
             location: nil,
+            annotations: [],
             comment: nil
           )
         end
@@ -648,8 +652,6 @@ module RBS
       end
 
       def block_from_ast_of(method)
-        return nil if RUBY_VERSION < '3.1'
-
         begin
           ast = RubyVM::AbstractSyntaxTree.of(method)
         rescue ArgumentError

data/lib/rbs/subtractor.rb

@@ -40,7 +40,7 @@ module RBS
           name = absolute_typename(decl.new_name, context: context)
           decl unless @subtrahend.module_alias?(name) || @subtrahend.module_decl?(name)
         else
-          raise "unknwon decl: #{(_ = decl).class}"
+          raise "unknown decl: #{(_ = decl).class}"
         end
       end.compact
     end
@@ -51,7 +51,7 @@ module RBS
       context = _ = [context, decl.name]
       children = call(decl.each_decl.to_a, context: context) +
         decl.each_member.reject { |m| member_exist?(owner, m, context: context) }
-      children = filter_redundunt_access_modifiers(children)
+      children = filter_redundant_access_modifiers(children)
       return nil if children.empty?
 
       update_decl(decl, members: children)
@@ -145,7 +145,7 @@ module RBS
       end
     end
 
-    private def filter_redundunt_access_modifiers(decls)
+    private def filter_redundant_access_modifiers(decls)
       decls = decls.dup
       decls.pop while access_modifier?(decls.last)
       decls = decls.map.with_index do |decl, i|

data/lib/rbs/test/hook.rb

@@ -27,8 +27,8 @@ module RBS
         :! => "not",
         :<< => "lshift",
         :>> => "rshift",
-        :~ => "tilda",
-        :=~ => "eqtilda",
+        :~ => "tilde",
+        :=~ => "eqtilde",
         :% => "percent",
         :+@ => "unary_plus",
         :-@ => "unary_minus"
@@ -96,50 +96,55 @@ def #{with_name}(#{param_source.join(", ")}, &#{block_param})
     block_calls = []
 
     if block_given?
-      receiver = self
       block_receives_block = #{block_param}.parameters.last&.yield_self {|type, _| type == :block }
 
-      wrapped_block = proc do |*block_args, &block2|
-        return_from_block = false
-
-        begin
-          block_result = if receiver.equal?(self)
-                           if block_receives_block
-                             #{block_param}.call(*block_args, &block2)
-                           else
-                             yield(*block_args)
-                           end
-                         else
-                           instance_exec(*block_args, &#{block_param})
-                         end
-
-          return_from_block = true
-        ensure
-          exn = $!
-
-          case
-          when return_from_block
-            # Returned from yield
-            block_calls << ::RBS::Test::ArgumentsReturn.return(
-              arguments: block_args,
-              value: block_result
-            )
-          when exn
-            # Exception
-            block_calls << ::RBS::Test::ArgumentsReturn.exception(
-              arguments: block_args,
-              exception: exn
-            )
-          else
-            # break?
-            block_calls << ::RBS::Test::ArgumentsReturn.break(
-              arguments: block_args
-            )
+      wrapped_block = Object.new.instance_exec do
+        new_object = self
+
+        proc do |*block_args, &block2|
+          return_from_block = false
+
+          begin
+            block_result = if self.equal?(new_object)
+                            if block_receives_block
+                              #{block_param}.call(*block_args, &block2)
+                            else
+                              yield(*block_args)
+                            end
+                          else
+                            # Detected that `self` inside `proc` is not equal to the `self` outside block (which is saved to `new_object`).
+                            # This means that the block is called with `instance_exec` or `instance_eval`.
+                            self.instance_exec(*block_args, &#{block_param})
+                          end
+
+            return_from_block = true
+          ensure
+            exn = $!
+
+            case
+            when return_from_block
+              # Returned from yield
+              block_calls << ::RBS::Test::ArgumentsReturn.return(
+                arguments: block_args,
+                value: block_result
+              )
+            when exn
+              # Exception
+              block_calls << ::RBS::Test::ArgumentsReturn.exception(
+                arguments: block_args,
+                exception: exn
+              )
+            else
+              # break?
+              block_calls << ::RBS::Test::ArgumentsReturn.break(
+                arguments: block_args
+              )
+            end
           end
-        end
 
-        block_result
-      end.ruby2_keywords
+          block_result
+        end.ruby2_keywords
+      end
 
       result = __send__(:"#{without_name}", *args, &wrapped_block)
     else

data/lib/rbs/test/type_check.rb

@@ -22,8 +22,8 @@ module RBS
       end
 
       def overloaded_call(method, method_name, call, errors:)
-        es = method.method_types.map do |method_type|
-          es = method_call(method_name, method_type, call, errors: [])
+        es = method.defs.map do |type_def|
+          es = method_call(method_name, type_def.type, call, errors: [], annotations: type_def.annotations)
 
           if es.empty?
             return errors
@@ -58,11 +58,11 @@ module RBS
         errors
       end
 
-      def method_call(method_name, method_type, call, errors:)
+      def method_call(method_name, method_type, call, errors:, annotations: [])
         return errors if method_type.type.is_a?(Types::UntypedFunction)
 
         args(method_name, method_type, method_type.type, call.method_call, errors, type_error: Errors::ArgumentTypeError, argument_error: Errors::ArgumentError)
-        self.return(method_name, method_type, method_type.type, call.method_call, errors, return_error: Errors::ReturnTypeError)
+        self.return(method_name, method_type, method_type.type, call.method_call, errors, return_error: Errors::ReturnTypeError, annotations:)
 
         if method_type.block
           case
@@ -106,8 +106,10 @@ module RBS
         end
       end
 
-      def return(method_name, method_type, fun, call, errors, return_error:)
+      def return(method_name, method_type, fun, call, errors, return_error:, annotations: [])
         if call.return?
+          return if Test.call(call.return_value, IS_AP, NilClass) && annotations.find { |a| a.string == "implicitly-returns-nil" }
+
           unless value(call.return_value, fun.return_type)
             errors << return_error.new(klass: self_class,
                                        method_name: method_name,

data/lib/rbs/type_name.rb

@@ -86,19 +86,24 @@ module RBS
         )
       end
     end
+    
+    def self.parse(string)
+      absolute = string.start_with?("::")
+
+      *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
+      raise unless name
+
+      TypeName.new(
+        name: name,
+        namespace: RBS::Namespace.new(path: path, absolute: absolute)
+      )
+    end
   end
 end
 
 module Kernel
   def TypeName(string)
-    absolute = string.start_with?("::")
-
-    *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
-    raise unless name
-
-    RBS::TypeName.new(
-      name: name,
-      namespace: RBS::Namespace.new(path: path, absolute: absolute)
-    )
+    warn "Kernel#TypeName() is deprecated. Use RBS::TypeName.parse instead.", category: :deprecated
+    RBS::TypeName.parse(string)
   end
 end

data/lib/rbs/types.rb

@@ -15,7 +15,7 @@ module RBS
     end
 
     module NoTypeName
-      def map_type_name
+      def map_type_name(&)
         self
       end
     end
@@ -107,13 +107,15 @@ module RBS
       class Bool < Base; end
       class Void < Base; end
       class Any < Base
-        def to_s(level=0)
-          @string || "untyped"
+        def initialize(location:, todo: false)
+          super(location: location)
+          if todo
+            @string = "__todo__"
+          end
         end
 
-        def todo!
-          @string = '__todo__'
-          self
+        def to_s(level=0)
+          @string || "untyped"
         end
       end
       class Nil < Base; end
@@ -229,7 +231,7 @@ module RBS
 
       include EmptyEachType
 
-      def map_type_name
+      def map_type_name(&)
         ClassSingleton.new(
           name: yield(name, location, self),
           location: location
@@ -323,6 +325,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(name: name,
                        args: args.map {|ty| ty.sub(s) },
                        location: location)
@@ -365,6 +369,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(name: name,
                        args: args.map {|ty| ty.sub(s) },
                        location: location)
@@ -407,6 +413,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         Alias.new(name: name, args: args.map {|ty| ty.sub(s) }, location: location)
       end
 
@@ -463,6 +471,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(types: types.map {|ty| ty.sub(s) },
                        location: location)
       end
@@ -521,15 +531,22 @@ module RBS
       def initialize(all_fields: nil, fields: nil, location:)
         case
         when fields && all_fields.nil?
-          @all_fields = fields.map { |k, v| [k, [v, true]] }.to_h
+          @all_fields = fields.transform_values { |v| [v, true] }
           @fields = fields
           @optional_fields = {}
         when all_fields && fields.nil?
           @all_fields = all_fields
-          @fields = all_fields.filter_map { |k, (v, required)| [k, v] if required }.to_h
-          @optional_fields = all_fields.filter_map { |k, (v, required)| [k, v] unless required }.to_h
+          @fields = {}
+          @optional_fields = {}
+          all_fields.each do |(k, (v, required))|
+            if required
+              @fields[k] = v
+            else
+              @optional_fields[k] = v
+            end
+          end
         else
-          raise ArgumentError, "only one of `:fields` or `:all_fields` is requireds"
+          raise ArgumentError, "only one of `:fields` or `:all_fields` is required"
         end
 
         @location = location
@@ -561,6 +578,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(
           all_fields: all_fields.transform_values {|ty, required| [ty.sub(s), required] },
           location: location
@@ -651,6 +670,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(type: type.sub(s), location: location)
       end
 
@@ -739,15 +760,26 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(types: types.map {|ty| ty.sub(s) },
                        location: location)
       end
 
       def to_s(level = 0)
+        strs = types.map do |ty|
+          case ty
+          when Intersection
+            ty.to_s([1, level].max)
+          else
+            ty.to_s
+          end
+        end
+
         if level > 0
-          "(#{types.join(" | ")})"
+          "(#{strs.join(" | ")})"
         else
-          types.join(" | ")
+          strs.join(" | ")
         end
       end
 
@@ -819,6 +851,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(types: types.map {|ty| ty.sub(s) },
                        location: location)
       end
@@ -1071,6 +1105,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         map_type {|ty| ty.sub(s) }
       end
 
@@ -1221,6 +1257,12 @@ module RBS
         end
       end
 
+      def map_type_name(&block)
+        UntypedFunction.new(
+          return_type: return_type.map_type_name(&block)
+        )
+      end
+
       def each_type(&block)
         if block
           yield return_type
@@ -1244,6 +1286,8 @@ module RBS
       end
 
       def sub(subst)
+        return self if subst.empty?
+
         map_type { _1.sub(subst) }
       end
 
@@ -1318,6 +1362,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(
           type: type.sub(s),
           required: required,
@@ -1387,6 +1433,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(
           type: type.sub(s),
           block: block&.sub(s),
@@ -1414,6 +1462,7 @@ module RBS
       def each_type(&block)
         if block
           type.each_type(&block)
+          yield self_type if self_type
           self.block&.type&.each_type(&block)
           if self_type = self.block&.self_type
             yield self_type
@@ -1454,7 +1503,7 @@ module RBS
       end
 
       def with_nonreturn_void?
-        if type.with_nonreturn_void?
+        if type.with_nonreturn_void? || self_type&.with_nonreturn_void?
           true
         else
           if block = block()

data/lib/rbs/unit_test/spy.rb

@@ -20,6 +20,8 @@ module RBS
         attr_reader :object
         attr_reader :method_name
 
+        NO_RETURN = Object.new
+
         def initialize(object:, method_name:)
           @callback = -> (_) { }
           @object = object
@@ -39,7 +41,7 @@ module RBS
             define_method(
               spy.method_name,
               _ = -> (*args, &block) do
-                return_value = nil
+                return_value = NO_RETURN
                 exception = nil
                 block_calls = [] #: Array[Test::ArgumentsReturn]
 
@@ -105,7 +107,7 @@ module RBS
                       arguments: args,
                       exception: exception
                     )
-                  when return_value
+                  when ::RBS::UnitTest::Spy::WrapSpy::NO_RETURN != return_value
                     Test::ArgumentsReturn.return(
                       arguments: args,
                       value: return_value

data/lib/rbs/unit_test/type_assertions.rb

@@ -15,7 +15,7 @@ module RBS
           @target = nil
         end
 
-        @@env_cache = {}
+        @@env_cache = {} #: Hash[Array[String], RBS::Environment]
 
         def env
           @env = @@env_cache[@libs] ||=
@@ -163,7 +163,7 @@ module RBS
           end
         end
 
-        last_trace = trace.last or raise
+        last_trace = trace.last or raise "empty trace"
 
         yield(mt, last_trace, result, exception)
       end
@@ -182,9 +182,9 @@ module RBS
 
           assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
 
-          method_types = method_types(method)
-          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
-          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_types.join(" | ")}"
+          method_defs = method_defs(method)
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
+          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
 
           raise exception if exception
 
@@ -219,30 +219,36 @@ module RBS
           assert_operator exception, :is_a?, ::Exception
           assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }
 
-          method_types = method_types(method)
-          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
-          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_types.join(" | ")}"
+          method_defs = method_defs(method)
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
+          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
 
           result
         end
       end
 
-      def method_types(method)
+      def method_defs(method)
         type, definition = target
 
         case type
         when Types::ClassInstance
           subst = RBS::Substitution.build(definition.type_params, type.args)
-          definition.methods[method].method_types.map do |method_type|
-            method_type.sub(subst)
+          definition.methods[method].defs.map do |type_def|
+            type_def.update(
+              type: type_def.type.sub(subst)
+            )
           end
         when Types::ClassSingleton
-          definition.methods[method].method_types
+          definition.methods[method].defs
         else
           raise
         end
       end
 
+      def method_types(method)
+        method_defs(method).map(&:type)
+      end
+
       def allows_error(*errors)
         yield
       rescue *errors => exn
@@ -271,7 +277,7 @@ module RBS
 
         assert typecheck.value(constant, value_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with given type `#{value_type}`"
 
-        type_name = TypeName(constant_name).absolute!
+        type_name = TypeName.parse(constant_name).absolute!
         definition = env.constant_entry(type_name)
         assert definition, "Cannot find RBS type definition of `#{constant_name}`"
 

data/lib/rbs/unit_test/with_aliases.rb

@@ -127,7 +127,9 @@ module RBS
 
             # `Range` requires `begin <=> end` to return non-nil, but doesn't actually
             # end up using the return value of it. This is to add that in when needed.
-            def lower.<=>(rhs) = :not_nil unless defined? lower.<=>
+            unless defined? lower.<=>
+              def lower.<=>(rhs) = :not_nil # steep:ignore MethodDefinitionInUndeclaredModule
+            end
 
             # If `lower <=> rhs` is defined but nil, then that means we're going to be constructing
             # an illegal range (eg `3..ToInt.new(4)`). So, we need to skip yielding an invalid range

data/lib/rbs/validator.rb

@@ -6,13 +6,15 @@ module RBS
     attr_reader :resolver
     attr_reader :definition_builder
 
-    def initialize(env:, resolver:)
+    def initialize(env:, resolver: nil)
       @env = env
       @resolver = resolver
       @definition_builder = DefinitionBuilder.new(env: env)
     end
 
     def absolute_type(type, context:, &block)
+      return type unless resolver
+
       type.map_type_name do |type_name, _, type|
         resolver.resolve(type_name, context: context) || (block ? yield(type) : type_name)
       end
@@ -149,6 +151,10 @@ module RBS
       end
     end
 
+    def validate_variable(var)
+      validate_type(var.type, context: nil)
+    end
+
     def validate_class_alias(entry:)
       case env.normalize_module_name?(entry.decl.new_name)
       when nil

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.6.1"
+  VERSION = "3.9.5"
 end

data/lib/rbs/writer.rb

@@ -77,14 +77,19 @@ module RBS
     end
 
     def write(contents)
-      dirs = contents.select {|c| c.is_a?(AST::Directives::Base) } #: Array[AST::Directives::t]
+      resolves = contents.select { _1.is_a?(AST::Directives::ResolveTypeNames) } #: Array[AST::Directives::ResolveTypeNames]
+      uses = contents.select {|c| c.is_a?(AST::Directives::Use) } #: Array[AST::Directives::Use]
       decls = contents.select {|c| c.is_a?(AST::Declarations::Base) } #: Array[AST::Declarations::t]
 
-      dirs.each do |dir|
-        write_directive(dir)
+      if first_resolves = resolves.first
+        puts "# resolve-type-names: #{first_resolves.value}"
+        puts
       end
 
-      puts unless dirs.empty?
+      uses.each do |dir|
+        write_use_directive(dir)
+      end
+      puts unless uses.empty?
 
       [nil, *decls].each_cons(2) do |prev, decl|
         raise unless decl
@@ -94,7 +99,7 @@ module RBS
       end
     end
 
-    def write_directive(dir)
+    def write_use_directive(dir)
       clauses = dir.clauses.map do |clause|
         case clause
         when AST::Directives::Use::SingleClause

data/lib/rbs.rb

@@ -9,6 +9,7 @@ require "pp"
 require "ripper"
 require "logger"
 require "tsort"
+require "strscan"
 
 require "rbs/errors"
 require "rbs/buffer"