rbs 2.8.4 → 3.8.1

data/lib/rbs/test/errors.rb

@@ -29,35 +29,48 @@ module RBS
         end
       end
 
+      RESPOND_TO = ::Kernel.instance_method :respond_to?
+      private_constant :RESPOND_TO
+
       def self.inspect_(obj)
-        if obj.respond_to?(:inspect)
+        if RESPOND_TO.bind_call(obj, :inspect)
           obj.inspect
         else
           Test::INSPECT.bind(obj).call     # For the case inspect is not defined (like BasicObject)
         end
       end
 
+      def self.method_tag(error)
+        if error.klass.singleton_class?
+          name = inspect_(error.klass).sub(/\A#<Class:(.*)>\z/, '\1')
+          method_name = ".#{error.method_name}"
+        else
+          name = error.klass.name
+          method_name = "##{error.method_name}"
+        end
+        "[#{name}#{method_name}]"
+      end
+
       def self.to_string(error)
-        method = "#{error.klass.name}#{error.method_name}"
         case error
         when ArgumentTypeError
-          "[#{method}] ArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+          "#{method_tag(error)} ArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
         when BlockArgumentTypeError
-          "[#{method}] BlockArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+          "#{method_tag(error)} BlockArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
         when ArgumentError
-          "[#{method}] ArgumentError: expected method type #{error.method_type}"
+          "#{method_tag(error)} ArgumentError: expected method type #{error.method_type}"
         when BlockArgumentError
-          "[#{method}] BlockArgumentError: expected method type #{error.method_type}"
+          "#{method_tag(error)} BlockArgumentError: expected method type #{error.method_type}"
         when ReturnTypeError
-          "[#{method}] ReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+          "#{method_tag(error)} ReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
         when BlockReturnTypeError
-          "[#{method}] BlockReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+          "#{method_tag(error)} BlockReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
         when UnexpectedBlockError
-          "[#{method}] UnexpectedBlockError: unexpected block is given for `#{error.method_type}`"
+          "#{method_tag(error)} UnexpectedBlockError: unexpected block is given for `#{error.method_type}`"
         when MissingBlockError
-          "[#{method}] MissingBlockError: required block is missing for `#{error.method_type}`"
+          "#{method_tag(error)} MissingBlockError: required block is missing for `#{error.method_type}`"
         when UnresolvedOverloadingError
-          "[#{method}] UnresolvedOverloadingError: couldn't find a suitable overloading"
+          "#{method_tag(error)} UnresolvedOverloadingError: couldn't find a suitable overloading"
         else
           raise "Unexpected error: #{inspect_(error)}"
         end

data/lib/rbs/test/guaranteed.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RBS
+  module Test
+    module Guaranteed
+      module Inspect
+        EQUAL = ::BasicObject.instance_method(:equal?)
+        INSPECT = ::Kernel.instance_method(:inspect)
+        private_constant :EQUAL, :INSPECT
+
+        module_function def guaranteed_inspect(obj)
+          obj.inspect
+        rescue NoMethodError
+          INSPECT.bind_call(obj)
+        end
+
+        def inspect
+          string = "<#{self.class.name}:"
+
+          instance_variables.each_with_index do |variable, index|
+            string.concat ', ' unless index.zero?
+            string.concat "#{variable}: #{guaranteed_inspect(instance_variable_get(variable))}"
+          end
+
+          string.concat '>'
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/hook.rb

@@ -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/setup.rb

@@ -67,7 +67,7 @@ TracePoint.trace :end do |tp|
 
   if class_name
     if filter.any? {|f| match(to_absolute_typename(f).to_s, class_name.to_s) } && skips.none? {|f| match(f, class_name.to_s) }
-      if env.class_decls.key?(class_name)
+      if env.module_name?(class_name)
         logger.info "Setting up hooks for #{class_name}"
         tester.install!(tp.self, sample_size: sample_size, unchecked_classes: unchecked_classes)
       end

data/lib/rbs/test/tester.rb

@@ -149,7 +149,7 @@ module RBS
           method = definition.methods[method_name]
           if method
             RBS.logger.debug { "Type checking `#{self_class}#{format_method_name(method_name)}`..."}
-            errors = check.overloaded_call(method, format_method_name(method_name), trace, errors: [])
+            errors = check.overloaded_call(method, method_name, trace, errors: [])
 
             if errors.empty?
               RBS.logger.debug { "No type error detected 👏" }

data/lib/rbs/test/type_check.rb

@@ -10,8 +10,6 @@ module RBS
       attr_reader :instance_class
       attr_reader :class_class
 
-      attr_reader :const_cache
-
       DEFAULT_SAMPLE_SIZE = 100
 
       def initialize(self_class:, builder:, sample_size:, unchecked_classes:, instance_class: Object, class_class: Module)
@@ -21,7 +19,6 @@ module RBS
         @builder = builder
         @sample_size = sample_size
         @unchecked_classes = unchecked_classes.uniq
-        @const_cache = {}
       end
 
       def overloaded_call(method, method_name, call, errors:)
@@ -38,17 +35,32 @@ module RBS
         if es.size == 1
           errors.push(*es[0])
         else
-          errors << Errors::UnresolvedOverloadingError.new(
+          error = Errors::UnresolvedOverloadingError.new(
             klass: self_class,
             method_name: method_name,
             method_types: method.method_types
           )
+          RBS.logger.warn do
+            tag = Errors.method_tag(error)
+            message = +"#{tag} UnresolvedOverloadingError "
+            message << method.method_types.zip(es).map do |method_type, es|
+              msg = +"method_type=`#{method_type}`"
+              details = es.map do |e|
+                "\"#{Errors.to_string(e).sub("#{tag} ", "") }\""
+              end.join(', ')
+              msg << " details=[#{details}]"
+            end.join(', ')
+            message
+          end
+          errors << error
         end
 
         errors
       end
 
       def method_call(method_name, method_type, call, errors:)
+        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)
 
@@ -136,10 +148,12 @@ module RBS
       end
 
       def keyword?(value)
-        value.is_a?(Hash) && value.keys.all? {|key| key.is_a?(Symbol) }
+        Hash === value && value.each_key.all?(Symbol)
       end
 
       def zip_args(args, fun, &block)
+        return true if fun.is_a?(Types::UntypedFunction)
+
         case
         when args.empty?
           if fun.required_positionals.empty? && fun.trailing_positionals.empty? && fun.required_keywords.empty?
@@ -208,11 +222,9 @@ module RBS
       end
 
       def get_class(type_name)
-        const_cache[type_name] ||= begin
-                                     Object.const_get(type_name.to_s)
-                                   rescue NameError
-                                     nil
-                                   end
+        Object.const_get(type_name.to_s)
+      rescue NameError
+        nil
       end
 
       def is_double?(value)
@@ -248,6 +260,13 @@ module RBS
           Test.call(val, IS_AP, instance_class)
         when Types::ClassInstance
           klass = get_class(type.name) or return false
+          if params = builder.env.normalized_module_class_entry(type.name.absolute!)&.type_params
+            args = AST::TypeParam.normalize_args(params, type.args)
+            unless args == type.args
+              type = Types::ClassInstance.new(name: type.name, args: args, location: type.location)
+            end
+          end
+
           case
           when klass == ::Array
             Test.call(val, IS_AP, klass) && each_sample(val).all? {|v| value(v, type.args[0]) }
@@ -275,19 +294,22 @@ module RBS
                 end
               end
 
-              each_sample(values).all? do |v|
+              value_check = values.empty? || each_sample(values).all? do |v|
                 if v.size == 1
                   # Only one block argument.
                   value(v[0], type.args[0]) || value(v, type.args[0])
                 else
                   value(v, type.args[0])
                 end
-              end &&
-                if ret.equal?(self)
-                  type.args[1].is_a?(Types::Bases::Bottom)
-                else
-                  value(ret, type.args[1])
-                end
+              end
+
+              return_check = if ret.equal?(self)
+                type.args[1].is_a?(Types::Bases::Bottom)
+              else
+                value(ret, type.args[1])
+              end
+
+              value_check && return_check
             end
           else
             Test.call(val, IS_AP, klass)
@@ -301,16 +323,22 @@ module RBS
                             end
           val.is_a?(singleton_class)
         when Types::Interface
-          methods = Set.new(Test.call(val, METHODS))
-          if (definition = builder.build_interface(type.name))
-            definition.methods.each_key.all? do |method_name|
-              methods.member?(method_name)
+          if (definition = builder.build_interface(type.name.absolute!))
+            definition.methods.each.all? do |method_name, method|
+              next false unless Test.call(val, RESPOND_TOP, method_name)
+
+              meth = Test.call(val, METHOD, method_name)
+              method.defs.all? do |type_def|
+                type_def.member.overloads.all? do |overload|
+                  callable_argument?(meth.parameters, overload.method_type)
+                end
+              end
             end
           end
         when Types::Variable
           true
         when Types::Literal
-          val == type.literal
+          type.literal == val
         when Types::Union
           type.types.any? {|type| value(val, type) }
         when Types::Intersection
@@ -318,7 +346,7 @@ module RBS
         when Types::Optional
           Test.call(val, IS_AP, ::NilClass) || value(val, type.type)
         when Types::Alias
-          value(val, builder.expand_alias(type.name))
+          value(val, builder.expand_alias2(type.name.absolute!, type.args))
         when Types::Tuple
           Test.call(val, IS_AP, ::Array) &&
             type.types.map.with_index {|ty, index| value(val[index], ty) }.all?
@@ -331,6 +359,75 @@ module RBS
           false
         end
       end
+
+      private
+
+      def callable_argument?(parameters, method_type)
+        fun = method_type.type
+        take_has_rest = !!parameters.find { |(op, _)| op == :rest }
+
+        return true if fun.is_a?(Types::UntypedFunction)
+
+        fun.required_positionals.each do
+          op, _ = parameters.first
+          return false if op.nil? || op == :keyreq || op == :key || op == :keyrest
+          parameters.shift if op == :req || op == :opt
+        end
+
+        fun.optional_positionals.each do
+          op, _ = parameters.first
+          return false if op.nil? || op == :req || op == :keyreq || op == :key || op == :keyrest
+          parameters.shift if op == :opt
+        end
+
+        if fun.rest_positionals
+          op, _ = parameters.shift
+          return false if op.nil? || op != :rest
+        end
+
+        fun.trailing_positionals.each do
+          op, _ = parameters.first
+          return false if !take_has_rest && (op.nil? || op == :keyreq || op == :key || op == :keyrest)
+          index = parameters.find_index { |(op, _)| op == :req }
+          parameters.delete_at(index) if index
+        end
+
+        if fun.has_keyword?
+          return false if !take_has_rest && parameters.empty?
+
+          fun.required_keywords.each do |name, _|
+            return false if !take_has_rest && parameters.empty?
+            index = parameters.find_index { |(op, n)| (op == :keyreq || op == :key) && n == name }
+            parameters.delete_at(index) if index
+          end
+
+          if !fun.optional_keywords.empty?
+            fun.optional_keywords.each do |name, _|
+              return false if !take_has_rest && parameters.empty?
+              index = parameters.find_index { |(op, n)| op == :key && n == name }
+              parameters.delete_at(index) if index
+            end
+            op, _ = parameters.first
+            return false if op == :req
+          end
+
+          if fun.rest_keywords
+            op, _ = parameters.first
+            return false if (!take_has_rest && op.nil?)
+            # f(a) allows (Integer, a: Integer)
+            return false if op == :req && fun.required_keywords.empty?
+          end
+
+          op, _ = parameters.first
+          return true if (op == :req || op == :opt) && parameters.length == 1
+        end
+
+        # rest required arguments
+        op, _ = parameters.first
+        return false if op == :req || op == :keyreq
+
+        true
+      end
     end
   end
 end

data/lib/rbs/test.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require "securerandom"
+require "rbs/test/guaranteed"
 require "rbs/test/observer"
-require "rbs/test/spy"
 require "rbs/test/errors"
 require "rbs/test/type_check"
 require "rbs/test/tester"
@@ -21,8 +21,11 @@ module RBS
     PP = Kernel.instance_method(:pp)
     INSPECT = Kernel.instance_method(:inspect)
     METHODS = Kernel.instance_method(:methods)
+    RESPOND_TOP = Kernel.instance_method(:respond_to?)
 
     class ArgumentsReturn
+      include Guaranteed::Inspect
+
       attr_reader :arguments
       attr_reader :exit_value
       attr_reader :exit_type
@@ -82,11 +85,11 @@ module RBS
 
     if ::UnboundMethod.instance_methods.include?(:bind_call)
       def self.call(receiver, method, *args, &block)
-        method.bind_call(receiver, *args, &block)
+        __skip__ = method.bind_call(receiver, *args, &block)
       end
     else
       def self.call(receiver, method, *args, &block)
-        method.bind(receiver).call(*args, &block)
+        __skip__ = method.bind(receiver).call(*args, &block)
       end
     end
   end

data/lib/rbs/type_alias_dependency.rb

@@ -20,7 +20,7 @@ module RBS
       # Construct transitive closure, if not constructed already
       transitive_closure() unless @dependencies
 
-      # Check for recursive type alias
+      alias_name = env.normalize_type_name!(alias_name)
       @dependencies[alias_name][alias_name]
     end
 
@@ -32,7 +32,7 @@ module RBS
       # Initialize dependencies as an empty hash
       @dependencies = {}
       # Iterate over alias declarations inserted into environment
-      env.alias_decls.each do |name, entry|
+      env.type_alias_decls.each do |name, entry|
         # Construct a directed graph by recursively extracting type aliases
         @direct_dependencies[name] = direct_dependency(entry.decl.type)
         # Initialize dependencies with an empty hash
@@ -49,6 +49,16 @@ module RBS
       end
     end
 
+    def direct_dependencies_of(name)
+      name = env.normalize_type_name!(name)
+      @direct_dependencies[name]
+    end
+
+    def dependencies_of(name)
+      name = env.normalize_type_name!(name)
+      @dependencies[name].each_key.to_set
+    end
+
     private
 
     # Constructs directed graph recursively
@@ -61,7 +71,7 @@ module RBS
         end
       when RBS::Types::Alias
         # Append type name if the type is an alias
-        result << type.name
+        result << env.normalize_type_name(type.name)
       end
 
       result

data/lib/rbs/type_alias_regularity.rb

@@ -37,10 +37,12 @@ module RBS
     end
 
     def validate_alias_type(alias_type, names, types)
-      if names.include?(alias_type.name)
-        if ex_type = types[alias_type.name]
+      alias_name = env.normalize_type_name?(alias_type.name) or return
+
+      if names.include?(alias_name)
+        if ex_type = types[alias_name]
           unless compatible_args?(ex_type.args, alias_type.args)
-            diagnostics[alias_type.name] ||=
+            diagnostics[alias_name] ||=
               Diagnostic.new(type_name: alias_type.name, nonregular_type: alias_type)
           end
 
@@ -49,7 +51,7 @@ module RBS
           types[alias_type.name] = alias_type
         end
 
-        expanded = builder.expand_alias2(alias_type.name, alias_type.args)
+        expanded = builder.expand_alias2(alias_name, alias_type.args)
         each_alias_type(expanded) do |at|
           validate_alias_type(at, names, types)
         end
@@ -57,7 +59,7 @@ module RBS
     end
 
     def build_alias_type(name)
-      entry = env.alias_decls[name] or return
+      entry = env.type_alias_decls[name] or return
       unless entry.decl.type_params.empty?
         as = entry.decl.type_params.each.map {|param| Types::Variable.new(name: param.name, location: nil) }
         Types::Alias.new(name: name, args: as, location: nil)
@@ -75,22 +77,27 @@ module RBS
     end
 
     def nonregular?(type_name)
-      diagnostics[type_name]
+      diagnostics[env.normalize_type_name!(type_name)]
     end
 
     def each_mutual_alias_defs(&block)
-      # @type var each_node: TSort::_EachNode[TypeName]
-      each_node = __skip__ = -> (&block) do
-        env.alias_decls.each_value do |decl|
-          block[decl.name]
+      # @type var each_node: ^() { (TypeName) -> void } -> void
+      each_node = -> (&block) do
+        env.type_alias_decls.each_value do |decl|
+          if normalized = env.normalize_type_name?(decl.name)
+            block[normalized]
+          end
         end
       end
-      # @type var each_child: TSort::_EachChild[TypeName]
-      each_child = __skip__ = -> (name, &block) do
-        if env.alias_decls.key?(name)
+
+      # @type var each_child: ^(TypeName) { (TypeName) -> void } -> void
+      each_child = -> (name, &block) do
+        if env.type_alias_decls.key?(name)
           type = builder.expand_alias1(name)
           each_alias_type(type) do |ty|
-            block[ty.name]
+            if normalized = env.normalize_type_name?(ty.name)
+              block[normalized]
+            end
           end
         end
       end

data/lib/rbs/type_name.rb

@@ -9,12 +9,12 @@ module RBS
     def initialize(namespace:, name:)
       @namespace = namespace
       @name = name
-      @kind = case name.to_s[0,1]
-              when /[A-Z]/
+      @kind = case
+              when name.match?(/\A[A-Z]/)
                 :class
-              when /[a-z]/
+              when name.match?(/\A[a-z]/)
                 :alias
-              when "_"
+              when name.start_with?("_")
                 :interface
               else
                 # Defaults to :class
@@ -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