rbs 0.5.0 → 0.6.0

data/lib/rbs/errors.rb

@@ -125,6 +125,49 @@ module RBS
     end
   end
 
+  class NoSuperclassFoundError < StandardError
+    attr_reader :type_name
+    attr_reader :location
+
+    def initialize(type_name:, location:)
+      @type_name = type_name
+      @location = location
+
+      super "#{Location.to_string location}: Could not find super class: #{type_name}"
+    end
+
+    def self.check!(type_name, env:, location:)
+      env.class_decls.key?(type_name) or raise new(type_name: type_name, location: location)
+    end
+  end
+
+  class NoMixinFoundError < StandardError
+    attr_reader :type_name
+    attr_reader :member
+
+    def initialize(type_name:, member:)
+      @type_name = type_name
+      @member = member
+
+      super "#{Location.to_string location}: Could not find mixin: #{type_name}"
+    end
+
+    def location
+      member.location
+    end
+
+    def self.check!(type_name, env:, member:)
+      dic = case
+            when type_name.class?
+              env.class_decls
+            when type_name.interface?
+              env.interface_decls
+            end
+
+      dic.key?(type_name) or raise new(type_name: type_name, member: member)
+    end
+  end
+
   class DuplicatedMethodDefinitionError < StandardError
     attr_reader :decl
     attr_reader :location
@@ -187,17 +230,6 @@ module RBS
     end
   end
 
-  class MixedClassModuleDeclarationError < StandardError
-    attr_reader :name
-    attr_reader :decl
-
-    def initialize(name:, decl:)
-      @name = name
-      @decl = decl
-      super "#{Location.to_string decl.location}: Both class and module declarations: #{name}"
-    end
-  end
-
   class SuperclassMismatchError < StandardError
     attr_reader :name
     attr_reader :entry
@@ -209,20 +241,6 @@ module RBS
     end
   end
 
-  class ModuleSelfTypeMismatchError < StandardError
-    attr_reader :name
-    attr_reader :entry
-    attr_reader :location
-
-    def initialize(name:, entry:, location:)
-      @name = name
-      @entry = entry
-      @location = location
-
-      super "#{Location.to_string location}: Module self type mismatch: #{name}"
-    end
-  end
-
   class InconsistentMethodVisibilityError < StandardError
     attr_reader :type_name
     attr_reader :method_name

data/lib/rbs/factory.rb

@@ -0,0 +1,14 @@
+module RBS
+  class Factory
+    def type_name(string)
+      absolute = string.start_with?("::")
+
+      *path, name = string.delete_prefix("::").split("::").map(&:to_sym)
+
+      TypeName.new(
+        name: name,
+        namespace: Namespace.new(path: path, absolute: absolute)
+      )
+    end
+  end
+end

data/lib/rbs/parser.y

@@ -106,28 +106,28 @@ rule
       }
 
   module_decl:
-      annotations kMODULE start_new_scope class_name module_type_params module_self_type class_members kEND {
+      annotations kMODULE start_new_scope class_name module_type_params colon_module_self_types class_members kEND {
         reset_variable_scope
 
         location = val[1].location + val[7].location
         result = Declarations::Module.new(
           name: val[3].value,
           type_params: val[4]&.value || Declarations::ModuleTypeParams.empty,
-          self_type: val[5],
+          self_types: val[5],
           members: val[6],
           annotations: val[0],
           location: location,
           comment: leading_comment(val[0].first&.location || location)
         )
       }
-    | annotations kMODULE start_new_scope tUKEYWORD type class_members kEND {
+    | annotations kMODULE start_new_scope tUKEYWORD module_self_types class_members kEND {
         reset_variable_scope
 
         location = val[1].location + val[6].location
         result = Declarations::Module.new(
           name: val[3].value,
           type_params: Declarations::ModuleTypeParams.empty,
-          self_type: val[4],
+          self_types: val[4],
           members: val[5],
           annotations: val[0],
           location: location,
@@ -135,12 +135,50 @@ rule
         )
       }
 
-  module_self_type:
-      { result = nil }
-    | kCOLON type {
+  colon_module_self_types:
+      { result = [] }
+    | kCOLON module_self_types {
         result = val[1]
       }
 
+  module_self_types:
+      module_self_type {
+        result = [val[0]]
+      }
+    | module_self_types kCOMMA module_self_type {
+        result = val[0].push(val[2])
+      }
+
+  module_self_type:
+      qualified_name kLBRACKET type_list kRBRACKET {
+        name = val[0].value
+        args = val[2]
+        location = val[0].location + val[3].location
+
+        case
+        when name.class?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        when name.interface?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        else
+          raise SemanticsError.new("Module self type should be instance or interface", subject: val[0], location: val[0].location)
+        end
+      }
+    | qualified_name {
+        name = val[0].value
+        args = []
+        location = val[0].location
+
+        case
+        when name.class?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        when name.interface?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        else
+          raise SemanticsError.new("Module self type should be instance or interface", subject: val[0], location: val[0].location)
+        end
+      }
+
   class_members:
       { result = [] }
     | class_members class_member {
@@ -1030,6 +1068,7 @@ def initialize(type, buffer:, eof_re:)
   @eof = false
   @bound_variables_stack = []
   @comments = {}
+  @ascii_only = buffer.content.ascii_only?
 end
 
 def start_merged_variables_scope
@@ -1123,8 +1162,9 @@ def push_comment(string, location)
 end
 
 def new_token(type, value = input.matched)
-  start_index = input.charpos - input.matched.size
-  end_index = input.charpos
+  charpos = charpos(input)
+  start_index = charpos - input.matched.size
+  end_index = charpos
 
   location = RBS::Location.new(buffer: buffer,
                                            start_pos: start_index,
@@ -1133,6 +1173,14 @@ def new_token(type, value = input.matched)
   [type, LocatedValue.new(location: location, value: value)]
 end
 
+def charpos(scanner)
+  if @ascii_only
+    scanner.pos
+  else
+    scanner.charpos
+  end
+end
+
 def empty_params_result
   [
     [],
@@ -1250,8 +1298,9 @@ def next_token
     when input.scan(/\s+/)
       # skip
     when input.scan(/#(( *)|( ?(?<string>.*)))\n/)
-      start_index = input.charpos - input.matched.size
-      end_index = input.charpos-1
+      charpos = charpos(input)
+      start_index = charpos - input.matched.size
+      end_index = charpos-1
 
       location = RBS::Location.new(buffer: buffer,
                                                start_pos: start_index,

data/lib/rbs/prototype/rb.rb

@@ -81,7 +81,7 @@ module RBS
           mod = AST::Declarations::Module.new(
             name: const_to_name(module_name),
             type_params: AST::Declarations::ModuleTypeParams.empty,
-            self_type: nil,
+            self_types: [],
             members: [],
             annotations: [],
             location: nil,

data/lib/rbs/prototype/rbi.rb

@@ -69,7 +69,7 @@ module RBS
           members: [],
           annotations: [],
           location: nil,
-          self_type: nil,
+          self_types: [],
           comment: comment
         )
 

data/lib/rbs/prototype/runtime.rb

@@ -370,7 +370,7 @@ module RBS
         decl = AST::Declarations::Module.new(
           name: type_name,
           type_params: AST::Declarations::ModuleTypeParams.empty,
-          self_type: nil,
+          self_types: [],
           members: [],
           annotations: [],
           location: nil,

data/lib/rbs/test.rb

@@ -1,6 +1,9 @@
+require "securerandom"
+require "rbs/test/observer"
 require "rbs/test/spy"
 require "rbs/test/errors"
 require "rbs/test/type_check"
+require "rbs/test/tester"
 require "rbs/test/hook"
 
 module RBS
@@ -16,11 +19,86 @@ module RBS
     INSPECT = Kernel.instance_method(:inspect)
     METHODS = Kernel.instance_method(:methods)
 
-    ArgumentsReturn = Struct.new(:arguments, :return_value, :exception, keyword_init: true)
+    class ArgumentsReturn
+      attr_reader :arguments
+      attr_reader :exit_value
+      attr_reader :exit_type
+
+      def initialize(arguments:, exit_value:, exit_type:)
+        @arguments = arguments
+        @exit_value = exit_value
+        @exit_type = exit_type
+      end
+
+      def self.return(arguments:, value:)
+        new(arguments: arguments, exit_value: value, exit_type: :return)
+      end
+
+      def self.exception(arguments:, exception:)
+        new(arguments: arguments, exit_value: exception, exit_type: :exception)
+      end
+
+      def self.break(arguments:)
+        new(arguments: arguments, exit_value: nil, exit_type: :break)
+      end
+
+      def return_value
+        raise unless exit_type == :return
+        exit_value
+      end
+
+      def exception
+        raise unless exit_type == :exception
+        exit_value
+      end
+
+      def return?
+        exit_type == :return
+      end
+
+      def exception?
+        exit_type == :exception
+      end
+
+      def break?
+        exit_type == :break
+      end
+    end
+
     CallTrace = Struct.new(:method_name, :method_call, :block_calls, :block_given, keyword_init: true)
 
-    def self.call(receiver, method, *args, **kwargs, &block)
-      method.bind_call(receiver, *args, **kwargs, &block)
+    class <<self
+      attr_accessor :suffix
+
+      def reset_suffix
+        self.suffix = "RBS_TEST_#{SecureRandom.hex(3)}"
+      end
+    end
+
+    reset_suffix
+
+    if ::UnboundMethod.instance_methods.include?(:bind_call)
+      def self.call(receiver, method, *args, &block)
+        method.bind_call(receiver, *args, &block)
+      end
+    else
+      def self.call(receiver, method, *args, &block)
+        method.bind(receiver).call(*args, &block)
+      end
     end
   end
 end
+
+unless ::Module.private_instance_methods.include?(:ruby2_keywords)
+  class Module
+    private
+    def ruby2_keywords(*)
+    end
+  end
+end
+
+unless ::Proc.instance_methods.include?(:ruby2_keywords)
+  class Proc
+    def ruby2_keywords; end
+  end
+end

data/lib/rbs/test/errors.rb

@@ -28,7 +28,7 @@ module RBS
       end
 
       def self.inspect_(obj)
-        Hook.inspect_(obj)
+        Test::INSPECT.bind(obj).call
       end
 
       def self.to_string(error)

data/lib/rbs/test/hook.rb

@@ -3,291 +3,165 @@ require "pp"
 
 module RBS
   module Test
-    class Hook
-      class Error < Exception
-        attr_reader :errors
-
-        def initialize(errors)
-          @errors = errors
-          super "Type error detected: [#{errors.map {|e| Errors.to_string(e) }.join(", ")}]"
-        end
-      end
-
-      attr_reader :env
-      attr_reader :logger
-
-      attr_reader :instance_module
-      attr_reader :instance_methods
-      attr_reader :singleton_module
-      attr_reader :singleton_methods
-
-      attr_reader :klass
-      attr_reader :errors
-
-      def builder
-        @builder ||= DefinitionBuilder.new(env: env)
-      end
-
-      def typecheck
-        @typecheck ||= TypeCheck.new(self_class: klass, builder: builder)
-      end
-
-      def initialize(env, klass, logger:, raise_on_error: false)
-        @env = env
-        @logger = logger
-        @klass = klass
-
-        @instance_module = Module.new
-        @instance_methods = []
-
-        @singleton_module = Module.new
-        @singleton_methods = []
-
-        @errors = []
-
-        @raise_on_error = raise_on_error
-      end
-
-      def raise_on_error!(error = true)
-        @raise_on_error = error
-        self
-      end
-
-      def raise_on_error?
-        @raise_on_error
-      end
-
-      def prepend!
-        klass.prepend @instance_module
-        klass.singleton_class.prepend @singleton_module
+    module Hook
+      OPERATORS = {
+        :== => "eqeq",
+        :=== => "eqeqeq",
+        :+ => "plus",
+        :- => "minus",
+        :* => "star",
+        :/ => "slash",
+        :> => "gt",
+        :>= => "gteq",
+        :< => "lt",
+        :<= => "lteq",
+        :<=> => "ufo",
+        :& => "amp",
+        :| => "vbar",
+        :^ => "hat",
+        :! => "not",
+        :<< => "lshift",
+        :>> => "rshift",
+        :~ => "tilda"
+      }
+      def self.alias_names(target)
+        case target
+        when *OPERATORS.keys
+          name = OPERATORS[target]
+          [
+            "#{name}____with__#{Test.suffix}",
+            "#{name}____without__#{Test.suffix}"
+          ]
+        else
+          aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
 
-        if block_given?
-          yield
-          disable
+          [
+            "#{aliased_target}__with__#{Test.suffix}#{punctuation}",
+            "#{aliased_target}__without__#{Test.suffix}#{punctuation}"
+          ]
         end
-
-        self
       end
 
-      def self.install(env, klass, logger:)
-        new(env, klass, logger: logger).prepend!
-      end
-
-      def refinement
-        klass = self.klass
-        instance_module = self.instance_module
-        singleton_module = self.singleton_module
-
-        Module.new do
-          refine klass do
-            prepend instance_module
-          end
-
-          refine klass.singleton_class do
-            prepend singleton_module
-          end
-        end
-      end
+      def self.setup_alias_method_chain(klass, target)
+        with_method, without_method = alias_names(target)
 
-      def verify_all
-        type_name = Namespace.parse(klass.name).to_type_name.absolute!
+        RBS.logger.debug "alias name: #{target}, #{with_method}, #{without_method}"
 
-        builder.build_instance(type_name).tap do |definition|
-          definition.methods.each do |name, method|
-            if method.defined_in == type_name
-              unless method.annotations.any? {|a| a.string == "rbs:test:skip" }
-                logger.info "Installing a hook on #{type_name}##{name}: #{method.method_types.join(" | ")}"
-                verify instance_method: name, types: method.method_types
-              else
-                logger.info "Skipping test of #{type_name}##{name}"
-              end
-            end
-          end
-        end
+        klass.instance_eval do
+          alias_method without_method, target
+          alias_method target, with_method
 
-        builder.build_singleton(type_name).tap do |definition|
-          definition.methods.each do |name, method|
-            if method.defined_in == type_name || name == :new
-              unless method.annotations.any? {|a| a.string == "rbs:test:skip" }
-                logger.info "Installing a hook on #{type_name}.#{name}: #{method.method_types.join(" | ")}"
-                verify singleton_method: name, types: method.method_types
-              else
-                logger.info "Skipping test of #{type_name}.#{name}"
-              end
-            end
+          case
+          when public_method_defined?(without_method)
+            public target
+          when protected_method_defined?(without_method)
+            protected target
+          when private_method_defined?(without_method)
+            private target
           end
         end
-
-        self
-      end
-
-      def delegation(name, method_types, method_name)
-        hook = self
-
-        -> (*args, &block) do
-          hook.logger.debug { "#{method_name} receives arguments: #{hook.inspect_(args)}" }
-
-          block_calls = []
-
-          if block
-            original_block = block
-
-            block = hook.call(Object.new, INSTANCE_EVAL) do |fresh_obj|
-              ->(*as) do
-                hook.logger.debug { "#{method_name} receives block arguments: #{hook.inspect_(as)}" }
-
-                ret = if self.equal?(fresh_obj)
-                        original_block[*as]
-                      else
-                        hook.call(self, INSTANCE_EXEC, *as, &original_block)
-                      end
-
-                block_calls << ArgumentsReturn.new(
-                  arguments: as,
-                  return_value: ret,
-                  exception: nil
-                )
-
-                hook.logger.debug { "#{method_name} returns from block: #{hook.inspect_(ret)}" }
-
-                ret
-              end.ruby2_keywords
-            end
-          end
-
-          method = hook.call(self, METHOD, name)
-          klass = hook.call(self, CLASS)
-          singleton_klass = begin
-            hook.call(self, SINGLETON_CLASS)
-          rescue TypeError
-            nil
-          end
-          prepended = klass.ancestors.include?(hook.instance_module) || singleton_klass&.ancestors&.include?(hook.singleton_module)
-          exception = nil
-          result = begin
-             if prepended
-               method.super_method.call(*args, &block)
-             else
-               # Using refinement
-               method.call(*args, &block)
-             end
-          rescue Exception => e
-            exception = e
-            nil
-          end
-
-          hook.logger.debug { "#{method_name} returns: #{hook.inspect_(result)}" }
-
-          call = CallTrace.new(method_call: ArgumentsReturn.new(arguments: args, return_value: result, exception: exception),
-                               block_calls: block_calls,
-                               block_given: block != nil)
-
-          method_type_errors = method_types.map do |method_type|
-            hook.typecheck.method_call(method_name, method_type, call, errors: [])
-          end
-
-          new_errors = []
-
-          if method_type_errors.none?(&:empty?)
-            if (best_errors = hook.find_best_errors(method_type_errors))
-              new_errors.push(*best_errors)
-            else
-              new_errors << Errors::UnresolvedOverloadingError.new(
-                klass: hook.klass,
-                method_name: method_name,
-                method_types: method_types
-              )
-            end
-          end
-
-          unless new_errors.empty?
-            new_errors.each do |error|
-              hook.logger.error Errors.to_string(error)
-            end
-
-            hook.errors.push(*new_errors)
-
-            if hook.raise_on_error?
-              raise Error.new(new_errors)
-            end
-          end
-
-          result
-        end.ruby2_keywords
       end
 
-      def verify(instance_method: nil, singleton_method: nil, types:)
-        method_types = types.map do |type|
-          case type
-          when String
-            Parser.parse_method_type(type)
+      def self.hook_method_source(prefix, method_name, key)
+        with_name, without_name = alias_names(method_name)
+        full_method_name = "#{prefix}#{method_name}"
+
+        [__LINE__ + 1, <<RUBY]
+def #{with_name}(*args)
+  ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
+
+  begin
+    return_from_call = false
+    block_calls = []
+
+    if block_given?
+      result = __send__(:"#{without_name}", *args) do |*block_args|
+        return_from_block = false
+
+        begin
+          block_result = yield(*block_args)
+          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
-            type
+            # break?
+            block_calls << ::RBS::Test::ArgumentsReturn.break(
+              arguments: block_args
+            )
           end
         end
 
-        case
-        when instance_method
-          instance_methods << instance_method
-          call(self.instance_module, DEFINE_METHOD, instance_method, &delegation(instance_method, method_types, "##{instance_method}"))
-        when singleton_method
-          call(self.singleton_module, DEFINE_METHOD, singleton_method, &delegation(singleton_method, method_types, ".#{singleton_method}"))
-        end
-
-        self
+        block_result
       end
+    else
+      result = __send__(:"#{without_name}", *args)
+    end
+    return_from_call = true
+    result
+  ensure
+    exn = $!
+
+    case
+    when return_from_call
+      ::RBS.logger.debug { "#{full_method_name} return with value: " + result.inspect }
+      method_call = ::RBS::Test::ArgumentsReturn.return(
+        arguments: args,
+        value: result
+      )
+    when exn
+      ::RBS.logger.debug { "#{full_method_name} exit with exception: " + exn.inspect }
+      method_call = ::RBS::Test::ArgumentsReturn.exception(
+        arguments: args,
+        exception: exn
+      )
+    else
+      ::RBS.logger.debug { "#{full_method_name} exit with jump" }
+      method_call = ::RBS::Test::ArgumentsReturn.break(arguments: args)
+    end
 
-      def find_best_errors(errorss)
-        if errorss.size == 1
-          errorss[0]
-        else
-          no_arity_errors = errorss.select do |errors|
-            errors.none? do |error|
-              error.is_a?(Errors::ArgumentError) ||
-                error.is_a?(Errors::BlockArgumentError) ||
-                error.is_a?(Errors::MissingBlockError) ||
-                error.is_a?(Errors::UnexpectedBlockError)
-            end
-          end
+    trace = ::RBS::Test::CallTrace.new(
+      method_name: #{method_name.inspect},
+      method_call: method_call,
+      block_calls: block_calls,
+      block_given: block_given?,
+    )
 
-          unless no_arity_errors.empty?
-            # Choose a error set which doesn't include arity error
-            return no_arity_errors[0] if no_arity_errors.size == 1
-          end
-        end
-      end
+    ::RBS::Test::Observer.notify(#{key.inspect}, self, trace)
+  end
 
-      def self.backtrace(skip: 2)
-        raise
-      rescue => exn
-        exn.backtrace.drop(skip)
-      end
+  result
+end
 
-      def run
-        yield
-        self
-      ensure
-        disable
+ruby2_keywords :#{with_name}
+RUBY
       end
 
-      def call(receiver, method, *args, &block)
-        method.bind(receiver).call(*args, &block)
-      end
+      def self.hook_instance_method(klass, method, key:)
+        line, source = hook_method_source("#{klass}#", method, key)
 
-      def inspect_(obj)
-        Hook.inspect_(obj)
+        klass.module_eval(source, __FILE__, line)
+        setup_alias_method_chain klass, method
       end
 
-      def self.inspect_(obj)
-        obj.inspect
-      rescue
-        INSPECT.bind(obj).call()
-      end
+      def self.hook_singleton_method(klass, method, key:)
+        line, source = hook_method_source("#{klass}.",method, key)
 
-      def disable
-        self.instance_module.remove_method(*instance_methods)
-        self.singleton_module.remove_method(*singleton_methods)
-        self
+        klass.singleton_class.module_eval(source, __FILE__, line)
+        setup_alias_method_chain klass.singleton_class, method
       end
     end
   end