rbs-relaxed 3.9.0.1

data/lib/rbs/subtractor.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module RBS
+  class Subtractor
+    def initialize(minuend, subtrahend)
+      @minuend = minuend
+      @subtrahend = subtrahend
+    end
+
+    def call(minuend = @minuend, context: nil)
+      minuend.map do |decl|
+        case decl
+        when AST::Declarations::Constant
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.constant_name?(name)
+        when AST::Declarations::Interface
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.interface_name?(name)
+        when AST::Declarations::Class, AST::Declarations::Module
+          name = absolute_typename(decl.name, context: context)
+          case
+          when @subtrahend.class_decl?(name) && decl.is_a?(AST::Declarations::Class)
+            filter_members(decl, context: context)
+          when @subtrahend.module_decl?(name) && decl.is_a?(AST::Declarations::Module)
+            filter_members(decl, context: context)
+          when @subtrahend.constant_name?(name)
+            nil
+          else
+            decl
+          end
+        when AST::Declarations::Global
+          decl unless @subtrahend.global_decls[decl.name]
+        when AST::Declarations::TypeAlias
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.type_alias_decls[name]
+        when AST::Declarations::ClassAlias
+          name = absolute_typename(decl.new_name, context: context)
+          decl unless @subtrahend.class_alias?(name) || @subtrahend.class_decl?(name)
+        when AST::Declarations::ModuleAlias
+          name = absolute_typename(decl.new_name, context: context)
+          decl unless @subtrahend.module_alias?(name) || @subtrahend.module_decl?(name)
+        else
+          raise "unknown decl: #{(_ = decl).class}"
+        end
+      end.compact
+    end
+
+    private def filter_members(decl, context:)
+      owner = absolute_typename(decl.name, context: context)
+
+      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_redundant_access_modifiers(children)
+      return nil if children.empty?
+
+      update_decl(decl, members: children)
+    end
+
+    private def member_exist?(owner, member, context:)
+      case member
+      when AST::Members::MethodDefinition
+        method_exist?(owner, member.name, member.kind)
+      when AST::Members::Alias
+        method_exist?(owner, member.new_name, member.kind)
+      when AST::Members::AttrReader
+        method_exist?(owner, member.name, member.kind)
+      when AST::Members::AttrWriter
+        method_exist?(owner, :"#{member.name}=", member.kind)
+      when AST::Members::AttrAccessor
+        # TODO: It unexpectedly removes attr_accessor even if either reader or writer does not exist in the subtrahend.
+        method_exist?(owner, member.name, member.kind) || method_exist?(owner, :"#{member.name}=", member.kind)
+      when AST::Members::InstanceVariable
+        ivar_exist?(owner, member.name, :instance)
+      when AST::Members::ClassInstanceVariable
+        ivar_exist?(owner, member.name, :singleton)
+      when AST::Members::ClassVariable
+        cvar_exist?(owner, member.name)
+      when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+        mixin_exist?(owner, member, context: context)
+      when AST::Members::Public, AST::Members::Private
+        # They should not be removed even if the subtrahend has them.
+        false
+      else
+        raise "unknown member: #{(_ = member).class}"
+      end
+    end
+
+    private def method_exist?(owner, method_name, kind)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::MethodDefinition
+          m.name == method_name && m.kind == kind
+        when AST::Members::Alias
+          m.new_name == method_name && m.kind == kind
+        when AST::Members::AttrReader
+          m.name == method_name && m.kind == kind
+        when AST::Members::AttrWriter
+          :"#{m.name}=" == method_name && m.kind == kind
+        when AST::Members::AttrAccessor
+          (m.name == method_name || :"#{m.name}=" == method_name) && m.kind == kind
+        end
+      end
+    end
+
+    private def ivar_exist?(owner, name, kind)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::InstanceVariable
+          m.name == name
+        when AST::Members::Attribute
+          ivar_name = m.ivar_name == false ? nil : m.ivar_name || :"@#{m.name}"
+          ivar_name == name && m.kind == kind
+        end
+      end
+    end
+
+    private def cvar_exist?(owner, name)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::ClassVariable
+          m.name == name
+        end
+      end
+    end
+
+    private def each_member(owner, &block)
+      return enum_for((__method__ or raise), owner) unless block
+
+      entry = @subtrahend.class_decls[owner]
+      return unless entry
+      decls = entry.decls.map { |d| d.decl }
+
+      decls.each { |d| d.members.each { |m| block.call(m) } }
+    end
+
+    private def mixin_exist?(owner, mixin, context:)
+      candidates = typename_candidates(mixin.name, context: context)
+      each_member(owner).any? do |m|
+        case m
+        when mixin.class
+          # @type var m: AST::Members::Include | AST::Members::Extend | AST::Members::Prepend
+          candidates.include?(m.name)
+        end
+      end
+    end
+
+    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|
+        if access_modifier?(decl) && access_modifier?(decls[i + 1])
+          nil
+        else
+          decl
+        end
+      end.compact
+    end
+
+    private def access_modifier?(decl)
+      decl.is_a?(AST::Members::Public) || decl.is_a?(AST::Members::Private)
+    end
+
+    private def update_decl(decl, members:)
+      case decl
+      when AST::Declarations::Class
+        decl.class.new(name: decl.name, type_params: decl.type_params, super_class: decl.super_class,
+                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
+                        members: members)
+      when AST::Declarations::Module
+        decl.class.new(name: decl.name, type_params: decl.type_params, self_types: decl.self_types,
+                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
+                        members: members)
+      end
+    end
+
+    private def absolute_typename(name, context:)
+      while context
+        ns = context[1] or raise
+        name = name.with_prefix(ns.to_namespace)
+        context = _ = context[0]
+      end
+      name.absolute!
+    end
+
+    private def typename_candidates(name, context:)
+      ret = [name.absolute!, name.relative!]
+      return ret if name.absolute?
+
+      while context
+        ns = context[1] or raise
+        name = name.with_prefix(ns.to_namespace)
+        ret.concat [name.absolute!, name.relative!]
+
+        context = _ = context[0]
+      end
+
+      ret
+    end
+  end
+end

data/lib/rbs/test/errors.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RBS
+  module Test
+    module Errors
+      ArgumentTypeError =
+        Struct.new(:klass, :method_name, :method_type, :param, :value, keyword_init: true)
+      BlockArgumentTypeError =
+        Struct.new(:klass, :method_name, :method_type, :param, :value, keyword_init: true)
+      ArgumentError =
+        Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+      BlockArgumentError =
+        Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+      ReturnTypeError =
+        Struct.new(:klass, :method_name, :method_type, :type, :value, keyword_init: true)
+      BlockReturnTypeError =
+        Struct.new(:klass, :method_name, :method_type, :type, :value, keyword_init: true)
+
+      UnexpectedBlockError = Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+      MissingBlockError = Struct.new(:klass, :method_name, :method_type, keyword_init: true)
+
+      UnresolvedOverloadingError = Struct.new(:klass, :method_name, :method_types, keyword_init: true)
+
+      def self.format_param(param)
+        if param.name
+          "`#{param.type}` (#{param.name})"
+        else
+          "`#{param.type}`"
+        end
+      end
+
+      RESPOND_TO = ::Kernel.instance_method :respond_to?
+      private_constant :RESPOND_TO
+
+      def self.inspect_(obj)
+        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)
+        case error
+        when ArgumentTypeError
+          "#{method_tag(error)} ArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+        when BlockArgumentTypeError
+          "#{method_tag(error)} BlockArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
+        when ArgumentError
+          "#{method_tag(error)} ArgumentError: expected method type #{error.method_type}"
+        when BlockArgumentError
+          "#{method_tag(error)} BlockArgumentError: expected method type #{error.method_type}"
+        when ReturnTypeError
+          "#{method_tag(error)} ReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+        when BlockReturnTypeError
+          "#{method_tag(error)} BlockReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
+        when UnexpectedBlockError
+          "#{method_tag(error)} UnexpectedBlockError: unexpected block is given for `#{error.method_type}`"
+        when MissingBlockError
+          "#{method_tag(error)} MissingBlockError: required block is missing for `#{error.method_type}`"
+        when UnresolvedOverloadingError
+          "#{method_tag(error)} UnresolvedOverloadingError: couldn't find a suitable overloading"
+        else
+          raise "Unexpected error: #{inspect_(error)}"
+        end
+      end
+    end
+  end
+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

@@ -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