rbs 4.1.0.pre.2-java

data/lib/rbs/test/hook.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "rbs"
+require "pp"
+
+module RBS
+  module Test
+    module Hook
+      OPERATORS = {
+        :[] => "indexlookup",
+        :[]= => "indexset",
+        :== => "eqeq",
+        :=== => "eqeqeq",
+        :!= => "noteq",
+        :+ => "plus",
+        :- => "minus",
+        :* => "star",
+        :/ => "slash",
+        :> => "gt",
+        :>= => "gteq",
+        :< => "lt",
+        :<= => "lteq",
+        :<=> => "ufo",
+        :& => "amp",
+        :| => "vbar",
+        :^ => "hat",
+        :! => "not",
+        :<< => "lshift",
+        :>> => "rshift",
+        :~ => "tilde",
+        :=~ => "eqtilde",
+        :% => "percent",
+        :+@ => "unary_plus",
+        :-@ => "unary_minus"
+      }
+      def self.alias_names(target, random)
+        suffix = "#{RBS::Test.suffix}_#{random}"
+
+        case target
+        when *OPERATORS.keys
+          name = OPERATORS[target]
+          [
+            "#{name}____with__#{suffix}",
+            "#{name}____without__#{suffix}"
+          ]
+        else
+          aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+
+          [
+            "#{aliased_target}__with__#{suffix}#{punctuation}",
+            "#{aliased_target}__without__#{suffix}#{punctuation}"
+          ]
+        end
+      end
+
+      def self.setup_alias_method_chain(klass, target, random:)
+        with_method, without_method = alias_names(target, random)
+
+        RBS.logger.debug "alias name: #{target}, #{with_method}, #{without_method}"
+
+        klass.instance_eval do
+          alias_method without_method, target
+          alias_method target, with_method
+
+          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
+      end
+
+      def self.hook_method_source(prefix, method_name, key, random:, params:)
+        with_name, without_name = alias_names(method_name, random)
+        full_method_name = "#{prefix}#{method_name}"
+
+        param_source = params.take_while {|param| param[0] == :req }
+                             .map.with_index {|pair, index| pair[1] || "__req__#{random}__#{index}" }
+        param_source.push("*rest_args__#{random}")
+        block_param = "block__#{random}"
+
+        RBS.logger.debug {
+          "Generating method definition: def #{with_name}(#{param_source.join(", ")}, &#{block_param}) ..."
+        }
+
+        [__LINE__ + 1, <<RUBY]
+def #{with_name}(#{param_source.join(", ")}, &#{block_param})
+  args = [#{param_source.join(", ")}]
+  ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
+
+  begin
+    return_from_call = false
+    block_calls = []
+
+    if block_given?
+      block_receives_block = #{block_param}.parameters.last&.yield_self {|type, _| type == :block }
+
+      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
+
+          block_result
+        end.ruby2_keywords
+      end
+
+      result = __send__(:"#{without_name}", *args, &wrapped_block)
+    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
+
+    trace = ::RBS::Test::CallTrace.new(
+      method_name: #{method_name.inspect},
+      method_call: method_call,
+      block_calls: block_calls,
+      block_given: block_given?,
+    )
+
+    ::RBS::Test::Observer.notify(#{key.inspect}, self, trace)
+  end
+
+  result
+end
+
+ruby2_keywords :#{with_name}
+RUBY
+      end
+
+      def self.hook_instance_method(klass, method, key:)
+        random = SecureRandom.hex(4)
+        params = klass.instance_method(method).parameters
+        line, source = hook_method_source("#{klass}#", method, key, random: random, params: params)
+
+        klass.module_eval(source, __FILE__, line)
+        setup_alias_method_chain klass, method, random: random
+      end
+
+      def self.hook_singleton_method(klass, method, key:)
+        random = SecureRandom.hex(4)
+        params = klass.method(method).parameters
+        line, source = hook_method_source("#{klass}.",method, key, random: random, params: params)
+
+        klass.singleton_class.module_eval(source, __FILE__, line)
+        setup_alias_method_chain klass.singleton_class, method, random: random
+      end
+    end
+  end
+end

data/lib/rbs/test/observer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RBS
+  module Test
+    module Observer
+      @@observers = {}
+
+      class <<self
+        def notify(key, *args)
+          @@observers[key]&.call(*args)
+        end
+
+        def register(key, object = nil, &block)
+          @@observers[key] = object || block
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/setup.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "rbs"
+require "rbs/test"
+require "optparse"
+require "shellwords"
+require "rbs/cli"
+
+include RBS::Test::SetupHelper
+
+logger = Logger.new(STDERR)
+
+begin
+  opts = Shellwords.shellsplit(ENV["RBS_TEST_OPT"] || "-I sig")
+  filter = ENV.fetch('RBS_TEST_TARGET', "").split(',').map! { |e| e.strip }
+  skips = (ENV['RBS_TEST_SKIP'] || '').split(',').map! { |e| e.strip }
+  RBS.logger_level = (ENV["RBS_TEST_LOGLEVEL"] || "info")
+  logger.level = RBS.logger_level
+  sample_size = get_sample_size(ENV['RBS_TEST_SAMPLE_SIZE'] || '')
+  double_class = to_double_class(ENV['RBS_TEST_DOUBLE_SUITE'])
+  unchecked_classes = (ENV['RBS_TEST_UNCHECKED_CLASSES'] || '').split(',').map! { |unchecked_class| unchecked_class.strip }.push(*double_class)
+rescue InvalidSampleSizeError => exception
+  RBS.logger.error exception.message
+  exit 1
+end
+
+if filter.empty?
+  STDERR.puts "rbs/test/setup handles the following environment variables:"
+  STDERR.puts "  [REQUIRED] RBS_TEST_TARGET: test target class name, `Foo::Bar,Foo::Baz` for each class or `Foo::*` for all classes under `Foo`"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_SKIP: skip testing classes"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_OPT: options for signatures (`-r` for libraries or `-I` for signatures)"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_LOGLEVEL: one of debug|info|warn|error|fatal (defaults to info)"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_SAMPLE_SIZE: sets the amount of values in a collection to be type-checked (Set to `ALL` to type check all the values)"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_DOUBLE_SUITE: sets the double suite in use (currently supported: minitest | rspec)"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_UNCHECKED_CLASSES: sets the classes that would not be checked"
+  exit 1
+end
+
+options = RBS::CLI::LibraryOptions.new()
+
+OptionParser.new do |opts|
+  options.setup_library_options(opts)
+end.parse!(opts)
+
+loader = options.loader
+env = RBS::Environment.from_loader(loader).resolve_type_names
+
+def match(filter, name)
+  if filter.end_with?("*")
+    size = filter.size
+    name.start_with?(filter[0, size - 1]) || name == filter[0, size-3]
+  else
+    filter == name
+  end
+end
+
+def to_absolute_typename(type_name)
+  RBS::Factory.new().type_name(type_name).absolute!
+end
+
+tester = RBS::Test::Tester.new(env: env)
+
+module_name = Module.instance_method(:name)
+
+TracePoint.trace :end do |tp|
+  class_name = module_name.bind(tp.self).call&.yield_self {|name| to_absolute_typename name }
+
+  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.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
+    end
+  end
+end
+
+at_exit do
+  if $!.nil? || $!.is_a?(SystemExit) && $!.success?
+    if tester.targets.empty?
+      logger.debug { "No type checker was installed!" }
+    end
+  end
+end

data/lib/rbs/test/setup_helper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RBS
+  module Test
+    module SetupHelper
+      class InvalidSampleSizeError < StandardError
+        attr_reader :string
+
+        def initialize(string)
+          @string = string
+          super("Sample size should be a positive integer: `#{string}`")
+        end
+      end
+
+      DEFAULT_SAMPLE_SIZE = 100
+
+      def get_sample_size(string)
+        case string
+        when ""
+          DEFAULT_SAMPLE_SIZE
+        when 'ALL'
+          nil
+        else
+          int_size = string.to_i
+          raise InvalidSampleSizeError.new(string) unless int_size.positive?
+          int_size
+        end
+      end
+
+      def to_double_class(double_suite)
+        return nil unless double_suite
+
+        case double_suite.downcase.strip
+        when 'rspec'
+          [
+            '::RSpec::Mocks::Double',
+            '::RSpec::Mocks::InstanceVerifyingDouble',
+            '::RSpec::Mocks::ObjectVerifyingDouble',
+            '::RSpec::Mocks::ClassVerifyingDouble',
+          ]
+        when 'minitest'
+          ['::Minitest::Mock']
+        else
+          RBS.logger.warn "Unknown test suite - defaults to nil"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/tester.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RBS
+  module Test
+    class Tester
+      attr_reader :env
+      attr_reader :targets
+      attr_reader :instance_testers
+      attr_reader :singleton_testers
+
+      def initialize(env:)
+        @env = env
+        @targets = []
+        @instance_testers = {}
+        @singleton_testers = {}
+      end
+
+      def factory
+        @factory ||= Factory.new
+      end
+
+      def builder
+        @builder ||= DefinitionBuilder.new(env: env)
+      end
+
+      def skip_method?(type_name, method)
+        if method.implemented_in == type_name
+          if method.annotations.any? {|a| a.string == "rbs:test:skip" }
+            :skip
+          else
+            false
+          end
+        else
+          if method.annotations.any? {|a| a.string == "rbs:test:target" }
+            false
+          else
+            :implemented_in
+          end
+        end
+      end
+
+      def install!(klass, sample_size:, unchecked_classes:)
+        RBS.logger.info { "Installing runtime type checker in #{klass}..." }
+
+        type_name = factory.type_name(klass.name).absolute!
+
+        builder.build_instance(type_name).tap do |definition|
+          instance_key = new_key(type_name, "InstanceChecker")
+          tester, set = instance_testers[klass] ||= [
+            MethodCallTester.new(klass, builder, definition, kind: :instance, sample_size: sample_size, unchecked_classes: unchecked_classes),
+            Set[]
+          ]
+          Observer.register(instance_key, tester)
+
+          definition.methods.each do |name, method|
+            if reason = skip_method?(type_name, method)
+              unless reason == :implemented_in
+                RBS.logger.info { "Skipping ##{name} because of `#{reason}`..." }
+              end
+            else
+              if !set.include?(name) && (
+                  name == :initialize ||
+                  klass.instance_methods(false).include?(name) ||
+                  klass.private_instance_methods(false).include?(name))
+                RBS.logger.info { "Setting up method hook in ##{name}..." }
+                Hook.hook_instance_method klass, name, key: instance_key
+                set << name
+              end
+            end
+          end
+        end
+
+        builder.build_singleton(type_name).tap do |definition|
+          singleton_key = new_key(type_name, "SingletonChecker")
+          tester, set = singleton_testers[klass] ||= [
+            MethodCallTester.new(klass.singleton_class, builder, definition, kind: :singleton, sample_size: sample_size, unchecked_classes: unchecked_classes),
+            Set[]
+          ]
+          Observer.register(singleton_key, tester)
+
+          definition.methods.each do |name, method|
+            if reason = skip_method?(type_name, method)
+              unless reason == :implemented_in
+                RBS.logger.info { "Skipping .#{name} because of `#{reason}`..." }
+              end
+            else
+              if klass.methods(false).include?(name) && !set.include?(name)
+                RBS.logger.info { "Setting up method hook in .#{name}..." }
+                Hook.hook_singleton_method klass, name, key: singleton_key
+                set << name
+              end
+            end
+          end
+        end
+
+        targets << klass
+      end
+
+      def new_key(type_name, prefix)
+        "#{prefix}__#{type_name}__#{SecureRandom.hex(10)}"
+      end
+
+      class TypeError < Exception
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = errors
+
+          super "TypeError: #{errors.map {|e| Errors.to_string(e) }.join(", ")}"
+        end
+      end
+
+      class MethodCallTester
+        attr_reader :self_class
+        attr_reader :definition
+        attr_reader :builder
+        attr_reader :kind
+        attr_reader :sample_size
+        attr_reader :unchecked_classes
+
+        def initialize(self_class, builder, definition, kind:, sample_size:, unchecked_classes:)
+          @self_class = self_class
+          @definition = definition
+          @builder = builder
+          @kind = kind
+          @sample_size = sample_size
+          @unchecked_classes = unchecked_classes
+        end
+
+        def env
+          builder.env
+        end
+
+        def check
+          @check ||= TypeCheck.new(self_class: self_class, builder: builder, sample_size: sample_size, unchecked_classes: unchecked_classes)
+        end
+
+        def format_method_name(name)
+          case kind
+          when :instance
+            "##{name}"
+          when :singleton
+            ".#{name}"
+          end
+        end
+
+        def call(receiver, trace)
+          method_name = trace.method_name
+          method = definition.methods[method_name]
+          if method
+            RBS.logger.debug { "Type checking `#{self_class}#{format_method_name(method_name)}`..."}
+            errors = check.overloaded_call(method, method_name, trace, errors: [])
+
+            if errors.empty?
+              RBS.logger.debug { "No type error detected 👏" }
+            else
+              RBS.logger.debug { "Detected type error 🚨" }
+              raise TypeError.new(errors)
+            end
+          else
+            RBS.logger.error { "Type checking `#{self_class}#{method_name}` call but no method found in definition" }
+          end
+        end
+      end
+    end
+  end
+end