rbs 0.9.0 → 0.12.1

data/lib/rbs/substitution.rb

@@ -31,10 +31,11 @@ module RBS
     def apply(ty)
       case ty
       when Types::Variable
+        # @type var ty: Types::Variable
         mapping[ty.name] || ty
       when Types::Bases::Instance
-        if instance_type
-          instance_type
+        if t = instance_type
+          t
         else
           ty
         end
@@ -44,7 +45,7 @@ module RBS
     end
 
     def without(*vars)
-      self.class.new.tap do |subst|
+      Substitution.new.tap do |subst|
         subst.mapping.merge!(mapping)
         vars.each do |var|
           subst.mapping.delete(var)

data/lib/rbs/test/hook.rb

@@ -7,6 +7,7 @@ module RBS
       OPERATORS = {
         :== => "eqeq",
         :=== => "eqeqeq",
+        :!= => "noteq",
         :+ => "plus",
         :- => "minus",
         :* => "star",

data/lib/rbs/test/setup.rb

@@ -9,21 +9,26 @@ 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 }
+  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")
   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
-rescue Exception => e
-  raise e.message
+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
 
@@ -50,16 +55,16 @@ end
 
 tester = RBS::Test::Tester.new(env: env)
 
+module_name = Module.instance_method(:name)
+
 TracePoint.trace :end do |tp|
-  class_name = tp.self.name&.yield_self {|name| to_absolute_typename name }
+  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 tester.checkers.none? {|hook| hook.klass == tp.self }
-        if env.class_decls.key?(class_name)
-          logger.info "Setting up hooks for #{class_name}"
-          tester.install!(tp.self, sample_size: sample_size)
-        end
+      if env.class_decls.key?(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
@@ -67,8 +72,8 @@ end
 
 at_exit do
   if $!.nil? || $!.is_a?(SystemExit) && $!.success?
-    logger.warn "No type checker was installed! " if tester.checkers.empty?
+    if tester.targets.empty?
+      logger.debug { "No type checker was installed!" }
+    end
   end
 end
-
- 

data/lib/rbs/test/setup_helper.rb

@@ -24,6 +24,21 @@ module RBS
           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']
+        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

@@ -2,11 +2,15 @@ module RBS
   module Test
     class Tester
       attr_reader :env
-      attr_reader :checkers
+      attr_reader :targets
+      attr_reader :instance_testers
+      attr_reader :singleton_testers
 
       def initialize(env:)
         @env = env
-        @checkers = []
+        @targets = []
+        @instance_testers = {}
+        @singleton_testers = {}
       end
 
       def factory
@@ -17,34 +21,74 @@ module RBS
         @builder ||= DefinitionBuilder.new(env: env)
       end
 
-      def install!(klass, sample_size:)
+      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")
-          Observer.register(instance_key, MethodCallTester.new(klass, builder, definition, kind: :instance, sample_size: sample_size))
+          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 method.implemented_in == type_name
-              RBS.logger.info { "Setting up method hook in ##{name}..." }
-              Hook.hook_instance_method klass, name, key: instance_key
+            if reason = skip_method?(type_name, method)
+              unless reason == :implemented_in
+                RBS.logger.info { "Skipping ##{name} because of `#{reason}`..." }
+              end
+            else
+              if klass.instance_methods(false).include?(name) && !set.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")
-          Observer.register(singleton_key, MethodCallTester.new(klass.singleton_class, builder, definition, kind: :singleton, sample_size: sample_size))
+          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 method.implemented_in == type_name || name == :new
-              RBS.logger.info { "Setting up method hook in .#{name}..." }
-              Hook.hook_singleton_method klass, name, key: singleton_key
+            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)
@@ -67,13 +111,15 @@ module RBS
         attr_reader :builder
         attr_reader :kind
         attr_reader :sample_size
+        attr_reader :unchecked_classes
 
-        def initialize(self_class, builder, definition, kind:, sample_size:)
+        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
@@ -81,7 +127,7 @@ module RBS
         end
 
         def check
-          @check ||= TypeCheck.new(self_class: self_class, builder: builder, sample_size: sample_size)
+          @check ||= TypeCheck.new(self_class: self_class, builder: builder, sample_size: sample_size, unchecked_classes: unchecked_classes)
         end
 
         def format_method_name(name)

data/lib/rbs/test/type_check.rb

@@ -4,13 +4,18 @@ module RBS
       attr_reader :self_class
       attr_reader :builder
       attr_reader :sample_size
+      attr_reader :unchecked_classes
+
+      attr_reader :const_cache
 
       DEFAULT_SAMPLE_SIZE = 100
 
-      def initialize(self_class:, builder:, sample_size:)
+      def initialize(self_class:, builder:, sample_size:, unchecked_classes:)
         @self_class = self_class
         @builder = builder
         @sample_size = sample_size
+        @unchecked_classes = unchecked_classes.uniq
+        @const_cache = {}
       end
 
       def overloaded_call(method, method_name, call, errors:)
@@ -179,11 +184,37 @@ module RBS
         end
       end
 
-      def sample(array)
-        sample_size && (array.size > sample_size) ? array.sample(sample_size) : array
+      def each_sample(array, &block)
+        if block
+          if sample_size && array.size > sample_size
+            if sample_size > 0
+              size = array.size
+              sample_size.times do
+                yield array[rand(size)]
+              end
+            end
+          else
+            array.each(&block)
+          end
+        else
+          enum_for :each_sample, array
+        end
+      end
+
+      def get_class(type_name)
+        const_cache[type_name] ||= Object.const_get(type_name.to_s)
+      end
+
+      def is_double?(value)
+        unchecked_classes.any? { |unchecked_class| Test.call(value, IS_AP, Object.const_get(unchecked_class))}
       end
 
       def value(val, type)
+        if is_double?(val)
+          RBS.logger.info("A double (#{val.inspect}) is detected!")
+          return true 
+        end
+
         case type
         when Types::Bases::Any
           true
@@ -204,17 +235,14 @@ module RBS
         when Types::Bases::Instance
           Test.call(val, IS_AP, self_class)
         when Types::ClassInstance
-          klass = Object.const_get(type.name.to_s)
+          klass = get_class(type.name)
           case
           when klass == ::Array
-            Test.call(val, IS_AP, klass) && sample(val).yield_self do |val|
-              val.all? {|v| value(v, type.args[0]) }
-            end
+            Test.call(val, IS_AP, klass) && each_sample(val).all? {|v| value(v, type.args[0]) }
           when klass == ::Hash
-            Test.call(val, IS_AP, klass) && sample(val.keys).yield_self do |keys|
-              values = val.values_at(*keys)
-              keys.all? {|key| value(key, type.args[0]) } && values.all? {|v| value(v, type.args[1]) }
-            end 
+            Test.call(val, IS_AP, klass) && each_sample(val.keys).all? do |key|
+              value(key, type.args[0]) && value(val[key], type.args[1])
+            end
           when klass == ::Range
             Test.call(val, IS_AP, klass) && value(val.begin, type.args[0]) && value(val.end, type.args[0])
           when klass == ::Enumerator
@@ -235,7 +263,7 @@ module RBS
                 end
               end
 
-              sample(values).all? do |v|
+              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])
@@ -253,7 +281,7 @@ module RBS
             Test.call(val, IS_AP, klass)
           end
         when Types::ClassSingleton
-          klass = Object.const_get(type.name.to_s)
+          klass = get_class(type.name)
           val == klass
         when Types::Interface
           methods = Set.new(Test.call(val, METHODS))
@@ -278,7 +306,8 @@ module RBS
           Test.call(val, IS_AP, ::Array) &&
             type.types.map.with_index {|ty, index| value(val[index], ty) }.all?
         when Types::Record
-          Test::call(val, IS_AP, ::Hash)
+          Test::call(val, IS_AP, ::Hash) && 
+            type.fields.map {|key, type| value(val[key], type) }.all?
         when Types::Proc
           Test::call(val, IS_AP, ::Proc)
         else

data/lib/rbs/type_name.rb

@@ -1,3 +1,4 @@
+
 module RBS
   class TypeName
     attr_reader :namespace
@@ -14,13 +15,15 @@ module RBS
                 :alias
               when "_"
                 :interface
+              else
+                raise
               end
     end
 
     def ==(other)
       other.is_a?(self.class) && other.namespace == namespace && other.name == name
     end
-
+    
     alias eql? ==
 
     def hash
@@ -68,3 +71,17 @@ module RBS
     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)
+    )
+  end
+end

data/lib/rbs/type_name_resolver.rb

@@ -1,6 +1,6 @@
 module RBS
   class TypeNameResolver
-    Query = Struct.new(:type_name, :context, keyword_init: true)
+    Query = _ = Struct.new(:type_name, :context, keyword_init: true)
 
     attr_reader :all_names
     attr_reader :cache
@@ -36,15 +36,22 @@ module RBS
       query = Query.new(type_name: type_name, context: context)
       try_cache(query) do
         path_head, *path_tail = type_name.to_namespace.path
+        raise unless path_head
+
         name_head = TypeName.new(name: path_head, namespace: Namespace.empty)
 
-        absolute_head = context.each.find do |namespace|
+        absolute_head = context.find do |namespace|
+          # @type break: TypeName
           full_name = name_head.with_prefix(namespace)
           has_name?(full_name) and break full_name
         end
 
-        if absolute_head
+        case absolute_head
+        when TypeName
           has_name?(Namespace.new(path: absolute_head.to_namespace.path.push(*path_tail), absolute: true).to_type_name)
+        when Namespace
+          # This cannot happen because the `context.find` doesn't return a Namespace.
+          raise
         end
       end
     end

data/lib/rbs/types.rb

@@ -1,3 +1,4 @@
+
 module RBS
   module Types
     module NoFreeVariables
@@ -77,7 +78,7 @@ module RBS
           when Types::Bases::Class
             'class'
           else
-            raise "Unexpected base type: #{type.inspect}"
+            raise "Unexpected base type: #{inspect}"
           end
         end
       end
@@ -138,8 +139,6 @@ module RBS
           new(name: v, location: nil)
         when Array
           v.map {|x| new(name: x, location: nil) }
-        else
-          raise
         end
       end
 
@@ -227,7 +226,7 @@ module RBS
       end
 
       def each_type(&block)
-        if block_given?
+        if block
           args.each(&block)
         else
           enum_for :each_type
@@ -380,7 +379,7 @@ module RBS
       end
 
       def each_type(&block)
-        if block_given?
+        if block
           types.each(&block)
         else
           enum_for :each_type
@@ -445,7 +444,7 @@ module RBS
       end
 
       def each_type(&block)
-        if block_given?
+        if block
           fields.each_value(&block)
         else
           enum_for :each_type
@@ -492,11 +491,15 @@ module RBS
       end
 
       def to_s(level = 0)
-        if type.is_a?(RBS::Types::Literal) && type.literal.is_a?(Symbol)
-          "#{type.to_s(1)} ?"
-        else
-          "#{type.to_s(1)}?"
+        case t = type
+        when RBS::Types::Literal
+          case t.literal
+          when Symbol
+            return "#{type.to_s(1)} ?"
+          end
         end
+
+        "#{type.to_s(1)}?"
       end
 
       def each_type
@@ -560,7 +563,7 @@ module RBS
       end
 
       def each_type(&block)
-        if block_given?
+        if block
           types.each(&block)
         else
           enum_for :each_type
@@ -568,7 +571,7 @@ module RBS
       end
 
       def map_type(&block)
-        if block_given?
+        if block
           Union.new(types: types.map(&block), location: location)
         else
           enum_for :map_type
@@ -629,7 +632,7 @@ module RBS
       end
 
       def each_type(&block)
-        if block_given?
+        if block
           types.each(&block)
         else
           enum_for :each_type
@@ -637,7 +640,7 @@ module RBS
       end
 
       def map_type(&block)
-        if block_given?
+        if block
           Intersection.new(types: types.map(&block), location: location)
         else
           enum_for :map_type
@@ -672,8 +675,8 @@ module RBS
           self.class.hash ^ type.hash ^ name.hash
         end
 
-        def map_type
-          if block_given?
+        def map_type(&block)
+          if block
             Param.new(name: name, type: yield(type))
           else
             enum_for :map_type
@@ -772,7 +775,7 @@ module RBS
       end
 
       def map_type(&block)
-        if block_given?
+        if block
           Function.new(
             required_positionals: required_positionals.map {|param| param.map_type(&block) },
             optional_positionals: optional_positionals.map {|param| param.map_type(&block) },
@@ -810,7 +813,7 @@ module RBS
       end
 
       def each_param(&block)
-        if block_given?
+        if block
           required_positionals.each(&block)
           optional_positionals.each(&block)
           rest_positionals&.yield_self(&block)
@@ -891,7 +894,9 @@ module RBS
       end
 
       def param_to_s
+        # @type var params: Array[String]
         params = []
+
         params.push(*required_positionals.map(&:to_s))
         params.push(*optional_positionals.map {|p| "?#{p}"})
         params.push("*#{rest_positionals}") if rest_positionals
@@ -927,8 +932,9 @@ module RBS
       def drop_tail
         case
         when !trailing_positionals.empty?
+          last = trailing_positionals.last or raise
           [
-            trailing_positionals.last,
+            last,
             update(trailing_positionals: trailing_positionals.take(trailing_positionals.size - 1))
           ]
         else
@@ -960,7 +966,7 @@ module RBS
         self.class.hash ^ type.hash
       end
 
-      def free_variables(set)
+      def free_variables(set = Set[])
         type.free_variables(set)
       end
 
@@ -977,7 +983,7 @@ module RBS
       end
 
       def each_type(&block)
-        if block_given?
+        if block
           type.each_type(&block)
         else
           enum_for :each_type