rbs 3.3.2 → 3.4.0

data/lib/rbs/diff.rb

@@ -2,11 +2,12 @@
 
 module RBS
   class Diff
-    def initialize(type_name:, library_options:, after_path: [], before_path: [])
+    def initialize(type_name:, library_options:, after_path: [], before_path: [], detail: false)
       @type_name = type_name
       @library_options = library_options
       @after_path = after_path
       @before_path = before_path
+      @detail = detail
     end
 
     def each_diff(&block)
@@ -100,11 +101,12 @@ module RBS
       if definition_method
         prefix = kind == :instance ? "" : "self."
 
+        detail_to_s = @detail ? "[#{definition_method.defined_in} #{definition_method.accessibility}] " : ""
         if definition_method.alias_of
           first_def = definition_method.alias_of.defs.first #: Definition::Method::TypeDef
-          "alias #{prefix}#{key} #{prefix}#{first_def.member.name}"
+          "#{detail_to_s}alias #{prefix}#{key} #{prefix}#{first_def.member.name}"
         else
-          "def #{prefix}#{key}: #{definition_method.method_types.join(" | ")}"
+          "#{detail_to_s}def #{prefix}#{key}: #{definition_method.method_types.join(" | ")}"
         end
       else
         +"-"
@@ -113,7 +115,8 @@ module RBS
 
     def constant_to_s(constant)
       if constant
-        "#{constant.name.name}: #{constant.type}"
+        detail_to_s = @detail ? "[#{constant.name.namespace.to_type_name.to_s}] " : ""
+        "#{detail_to_s}#{constant.name.name}: #{constant.type}"
       else
         +"-"
       end

data/lib/rbs/errors.rb

@@ -557,4 +557,15 @@ module RBS
       @alias_entry.decl.location
     end
   end
+
+  class WillSyntaxError < DefinitionError
+    include DetailedMessageable
+
+    attr_reader :location
+
+    def initialize(message, location:)
+      super "#{Location.to_string(location)}: #{message}"
+      @location = location
+    end
+  end
 end

data/lib/rbs/test/errors.rb

@@ -29,8 +29,11 @@ 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)
@@ -38,7 +41,12 @@ module RBS
       end
 
       def self.to_string(error)
-        method = "#{error.klass.name}#{error.method_name}"
+        name = if error.klass.singleton_class?
+          inspect_(error.klass).sub(/\A#<Class:(.*)>\z/, '\1')
+        else
+          error.klass.name
+        end
+        method = "#{name}#{error.method_name}"
         case error
         when ArgumentTypeError
           "[#{method}] ArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"

data/lib/rbs/test/guaranteed.rb

@@ -10,8 +10,7 @@ module RBS
 
         module_function def guaranteed_inspect(obj)
           obj.inspect
-        rescue NoMethodError => err
-          raise unless err.name == :inspect && EQUAL.bind_call(obj, err.receiver)
+        rescue NoMethodError
           INSPECT.bind_call(obj)
         end
 
@@ -20,7 +19,7 @@ module RBS
 
           instance_variables.each_with_index do |variable, index|
             string.concat ', ' unless index.zero?
-            string.concat "#{variable}: #{guaranteed_inspect(variable)}"
+            string.concat "#{variable}: #{guaranteed_inspect(instance_variable_get(variable))}"
           end
 
           string.concat '>'

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,6 +35,17 @@ module RBS
         if es.size == 1
           errors.push(*es[0])
         else
+          RBS.logger.warn do
+            message = +"[#{self_class}#{method_name}] 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("[#{e.klass.name}#{e.method_name}] ", "") }\""
+              end.join(', ')
+              msg << " details=[#{details}]"
+            end.join(', ')
+            message
+          end
           errors << Errors::UnresolvedOverloadingError.new(
             klass: self_class,
             method_name: method_name,
@@ -208,11 +216,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)
@@ -301,10 +307,9 @@ 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.absolute!))
             definition.methods.each_key.all? do |method_name|
-              methods.member?(method_name)
+              Test.call(val, RESPOND_TOP, method_name)
             end
           end
         when Types::Variable

data/lib/rbs/test.rb

@@ -3,7 +3,6 @@
 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"
@@ -22,6 +21,7 @@ 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
@@ -85,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/types.rb

@@ -1399,6 +1399,35 @@ module RBS
       def with_nonreturn_void?
         false
       end
+
+      TABLE = {
+        "\\a" => "\a",
+        "\\b" => "\b",
+        "\\e" => "\033",
+        "\\f" => "\f",
+        "\\n" => "\n",
+        "\\r" => "\r",
+        "\\s" => " ",
+        "\\t" => "\t",
+        "\\v" => "\v",
+        "\\\"" => "\"",
+        "\\\'" => "'",
+        "\\\\" => "\\",
+        "\\" => ""
+      }
+
+      def self.unescape_string(string, is_double_quote)
+        if is_double_quote
+          string.gsub!(/\\([0-9]{1,3})/) { ($1 || "").to_i(8).chr }
+          string.gsub!(/\\x([0-9a-f]{1,2})/) { ($1 || "").to_i(16).chr }
+          string.gsub!(/\\u([0-9a-fA-F]{4})/) { ($1 || "").to_i(16).chr(Encoding::UTF_8) }
+          string.gsub!(/\\[abefnrstv"'\\]?/, TABLE)
+          string
+        else
+          string.gsub!(/\\['\\]/, TABLE)
+          string
+        end
+      end
     end
   end
 end

data/lib/rbs/unit_test/convertibles.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RBS
+  module UnitTest
+    module Convertibles
+      class BlankSlate < BasicObject
+        instance_methods.each do |im|
+          next if im == :__send__
+          undef_method im
+        end
+
+        def __with_object_methods(*methods)
+          methods.each do |method|
+            singleton_class = ::Object.instance_method(:singleton_class).bind_call(self) #: Class
+            singleton_class.instance_eval do
+              define_method method, ::Object.instance_method(method)
+            end
+          end
+          self
+        end
+      end
+
+      class ToIO < BlankSlate
+        def initialize(io = $stdout)
+          @io = io
+        end
+
+        def to_io
+          @io
+        end
+      end
+
+      class ToI < BlankSlate
+        def initialize(value = 3)
+          @value = value
+        end
+
+        def to_i
+          @value
+        end
+      end
+
+      class ToInt < BlankSlate
+        def initialize(value = 3)
+          @value = value
+        end
+
+        def to_int
+          @value
+        end
+      end
+
+      class ToF < BlankSlate
+        def initialize(value = 0.1)
+          @value = value
+        end
+
+        def to_f
+          @value
+        end
+      end
+
+      class ToR < BlankSlate
+        def initialize(value = 1r)
+          @value = value
+        end
+
+        def to_r
+          @value
+        end
+      end
+
+      class ToC < BlankSlate
+        def initialize(value = 1i)
+          @value = value
+        end
+
+        def to_c
+          @value
+        end
+      end
+
+      class ToStr < BlankSlate
+        def initialize(value = "")
+          @value = value
+        end
+
+        def to_str
+          @value
+        end
+      end
+
+      class ToS < BlankSlate
+        def initialize(value = "")
+          @value = value
+        end
+
+        def to_s
+          @value
+        end
+      end
+
+      class ToSym < BlankSlate
+        def initialize(value = :&)
+          @value = value
+        end
+
+        def to_sym
+          @value
+        end
+      end
+
+      class ToA < BlankSlate
+        def initialize(*args)
+          @args = args
+        end
+
+        def to_a
+          @args
+        end
+      end
+
+      class ToArray < BlankSlate
+        def initialize(*args)
+          @args = args
+        end
+
+        def to_ary
+          @args
+        end
+      end
+
+      class ToHash < BlankSlate
+        def initialize(hash = { 'hello' => 'world' })
+          @hash = hash
+        end
+
+        def to_hash
+          @hash
+        end
+      end
+
+      class ToPath < BlankSlate
+        def initialize(value = "")
+          @value = value
+        end
+
+        def to_path
+          @value
+        end
+      end
+
+      class CustomRange < BlankSlate
+        attr_reader :begin, :end
+
+        def initialize(begin_, end_, exclude_end = false)
+          @begin = begin_
+          @end = end_
+          @exclude_end = exclude_end
+        end
+
+        def exclude_end? = @exclude_end
+      end
+
+      class Each < BlankSlate
+        def initialize(*args)
+          @args = args
+        end
+
+        def each(&block)
+          @args.each(&block)
+        end
+      end
+    end
+  end
+end

data/lib/rbs/unit_test/spy.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RBS
+  module UnitTest
+    module Spy
+      def self.wrap(object, method_name)
+        spy = WrapSpy.new(object: object, method_name: method_name)
+
+        if block_given?
+          begin
+            yield spy, spy.wrapped_object
+          end
+        else
+          spy
+        end
+      end
+
+      class WrapSpy
+        attr_accessor :callback
+        attr_reader :object
+        attr_reader :method_name
+
+        def initialize(object:, method_name:)
+          @callback = -> (_) { }
+          @object = object
+          @method_name = method_name
+        end
+
+        def wrapped_object
+          spy = self #: WrapSpy[untyped]
+
+          Class.new(BasicObject) do
+            # @type self: Class
+
+            define_method(:method_missing) do |name, *args, &block|
+              spy.object.__send__(name, *args, &block)
+            end
+
+            define_method(
+              spy.method_name,
+              _ = -> (*args, &block) do
+                return_value = nil
+                exception = nil
+                block_calls = [] #: Array[Test::ArgumentsReturn]
+
+                spy_block = if block
+                              Object.new.instance_eval do |fresh|
+                                proc = -> (*block_args) do
+                                  block_exn = nil
+                                  block_return = nil
+
+                                  begin
+                                    block_return = if self.equal?(fresh)
+                                                    # no instance eval
+                                                    block.call(*block_args)
+                                                  else
+                                                    self.instance_exec(*block_args, &block)
+                                                  end
+                                  rescue Exception => exn
+                                    block_exn = exn
+                                  end
+
+                                  if block_exn
+                                    block_calls << Test::ArgumentsReturn.exception(
+                                      arguments: block_args,
+                                      exception: block_exn
+                                    )
+                                  else
+                                    block_calls << Test::ArgumentsReturn.return(
+                                      arguments: block_args,
+                                      value: block_return
+                                    )
+                                  end
+
+                                  if block_exn
+                                    raise block_exn
+                                  else
+                                    block_return
+                                  end
+                                end #: Proc
+
+                                proc.ruby2_keywords
+                              end
+                            end
+
+                begin
+                  if spy_block
+                    return_value = spy.object.__send__(spy.method_name, *args) do |*a, **k, &b|
+                      spy_block.call(*a, **k, &b)
+                    end
+                  else
+                    return_value = spy.object.__send__(spy.method_name, *args, &spy_block)
+                  end
+                rescue ::Exception => exn
+                  exception = exn
+                end
+
+                return_value
+
+              ensure
+                call =
+                  case
+                  when exception
+                    Test::ArgumentsReturn.exception(
+                      arguments: args,
+                      exception: exception
+                    )
+                  when return_value
+                    Test::ArgumentsReturn.return(
+                      arguments: args,
+                      value: return_value
+                    )
+                  else
+                    # break
+                    Test::ArgumentsReturn.break(arguments: args)
+                  end
+                trace = RBS::Test::CallTrace.new(
+                  method_name: spy.method_name,
+                  method_call: call,
+                  block_calls: block_calls,
+                  block_given: block != nil
+                )
+
+                spy.callback.call(trace)
+
+                if exception
+                  spy.object.__send__(:raise, exception)
+                end
+              end.ruby2_keywords
+            )
+          end.new()
+        end
+      end
+    end
+  end
+end