rbs 0.3.1 → 0.8.0

data/lib/rbs/test/tester.rb

@@ -0,0 +1,116 @@
+module RBS
+  module Test
+    class Tester
+      attr_reader :env
+      attr_reader :checkers
+
+      def initialize(env:)
+        @env = env
+        @checkers = []
+      end
+
+      def factory
+        @factory ||= Factory.new
+      end
+
+      def builder
+        @builder ||= DefinitionBuilder.new(env: env)
+      end
+
+      def install!(klass, sample_size:)
+        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))
+
+          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
+            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))
+
+          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
+            end
+          end
+        end
+      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
+
+        def initialize(self_class, builder, definition, kind:, sample_size:)
+          @self_class = self_class
+          @definition = definition
+          @builder = builder
+          @kind = kind
+          @sample_size = sample_size
+        end
+
+        def env
+          builder.env
+        end
+
+        def check
+          @check ||= TypeCheck.new(self_class: self_class, builder: builder, sample_size: sample_size)
+        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, format_method_name(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

data/lib/rbs/test/type_check.rb

@@ -3,10 +3,38 @@ module RBS
     class TypeCheck
       attr_reader :self_class
       attr_reader :builder
+      attr_reader :sample_size
 
-      def initialize(self_class:, builder:)
+      DEFAULT_SAMPLE_SIZE = 100
+
+      def initialize(self_class:, builder:, sample_size:)
         @self_class = self_class
         @builder = builder
+        @sample_size = sample_size
+      end
+
+      def overloaded_call(method, method_name, call, errors:)
+        es = method.method_types.map do |method_type|
+          es = method_call(method_name, method_type, call, errors: [])
+
+          if es.empty?
+            return errors
+          else
+            es
+          end
+        end
+
+        if es.size == 1
+          errors.push(*es[0])
+        else
+          errors << Errors::UnresolvedOverloadingError.new(
+            klass: self_class,
+            method_name: method_name,
+            method_types: method.method_types
+          )
+        end
+
+        errors
       end
 
       def method_call(method_name, method_type, call, errors:)
@@ -56,7 +84,7 @@ module RBS
       end
 
       def return(method_name, method_type, fun, call, errors, return_error:)
-        unless call.exception
+        if call.return?
           unless value(call.return_value, fun.return_type)
             errors << return_error.new(klass: self_class,
                                        method_name: method_name,
@@ -151,6 +179,10 @@ module RBS
         end
       end
 
+      def sample(array)
+        sample_size && (array.size > sample_size) ? array.sample(sample_size) : array
+      end
+
       def value(val, type)
         case type
         when Types::Bases::Any
@@ -175,9 +207,14 @@ module RBS
           klass = Object.const_get(type.name.to_s)
           case
           when klass == ::Array
-            Test.call(val, IS_AP, klass) && val.all? {|v| value(v, type.args[0]) }
+            Test.call(val, IS_AP, klass) && sample(val).yield_self do |val|
+              val.all? {|v| value(v, type.args[0]) }
+            end
           when klass == ::Hash
-            Test.call(val, IS_AP, klass) && val.all? {|k, v| value(k, type.args[0]) && value(v, type.args[1]) }
+            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 
           when klass == ::Range
             Test.call(val, IS_AP, klass) && value(val.begin, type.args[0]) && value(val.end, type.args[0])
           when klass == ::Enumerator
@@ -198,7 +235,7 @@ module RBS
                 end
               end
 
-              values.all? do |v|
+              sample(values).all? do |v|
                 if v.size == 1
                   # Only one block argument.
                   value(v[0], type.args[0]) || value(v, type.args[0])
@@ -220,8 +257,7 @@ module RBS
           val == klass
         when Types::Interface
           methods = Set.new(Test.call(val, METHODS))
-          decl = builder.env.find_class(type.name)
-          if (definition = builder.build_interface(type.name, decl))
+          if (definition = builder.build_interface(type.name))
             definition.methods.each_key.all? do |method_name|
               methods.member?(method_name)
             end

data/lib/rbs/type_name_resolver.rb

@@ -0,0 +1,58 @@
+module RBS
+  class TypeNameResolver
+    Query = Struct.new(:type_name, :context, keyword_init: true)
+
+    attr_reader :all_names
+    attr_reader :cache
+
+    def initialize()
+      @all_names = Set[]
+      @cache = {}
+    end
+
+    def self.from_env(env)
+      new.add_names(env.class_decls.keys)
+        .add_names(env.interface_decls.keys)
+        .add_names(env.alias_decls.keys)
+    end
+
+    def add_names(names)
+      all_names.merge(names)
+      self
+    end
+
+    def try_cache(query)
+      cache.fetch(query) do
+        result = yield
+        cache[query] = result
+      end
+    end
+
+    def resolve(type_name, context:)
+      if type_name.absolute?
+        return type_name
+      end
+
+      query = Query.new(type_name: type_name, context: context)
+      try_cache(query) do
+        path_head, *path_tail = type_name.to_namespace.path
+        name_head = TypeName.new(name: path_head, namespace: Namespace.empty)
+
+        absolute_head = context.each.find do |namespace|
+          full_name = name_head.with_prefix(namespace)
+          has_name?(full_name) and break full_name
+        end
+
+        if absolute_head
+          has_name?(Namespace.new(path: absolute_head.to_namespace.path.push(*path_tail), absolute: true).to_type_name)
+        end
+      end
+    end
+
+    def has_name?(full_name)
+      if all_names.include?(full_name)
+        full_name
+      end
+    end
+  end
+end

data/lib/rbs/types.rb

@@ -12,6 +12,12 @@ module RBS
       end
     end
 
+    module NoTypeName
+      def map_type_name
+        self
+      end
+    end
+
     module EmptyEachType
       def each_type
         if block_given?
@@ -43,6 +49,7 @@ module RBS
         include NoFreeVariables
         include NoSubst
         include EmptyEachType
+        include NoTypeName
 
         def to_json(*a)
           klass = to_s.to_sym
@@ -82,7 +89,11 @@ module RBS
       class Top < Base; end
       class Bottom < Base; end
       class Self < Base; end
-      class Instance < Base; end
+      class Instance < Base
+        def sub(s)
+          s.apply(self)
+        end
+      end
       class Class < Base; end
     end
 
@@ -90,6 +101,8 @@ module RBS
       attr_reader :name
       attr_reader :location
 
+      include NoTypeName
+
       def initialize(name:, location:)
         @name = name
         @location = location
@@ -174,6 +187,13 @@ module RBS
       end
 
       include EmptyEachType
+
+      def map_type_name
+        ClassSingleton.new(
+          name: yield(name, location, self),
+          location: location
+        )
+      end
     end
 
     module Application
@@ -235,6 +255,14 @@ module RBS
                        args: args.map {|ty| ty.sub(s) },
                        location: location)
       end
+
+      def map_type_name(&block)
+        Interface.new(
+          name: yield(name, location, self),
+          args: args.map {|type| type.map_type_name(&block) },
+          location: location
+        )
+      end
     end
 
     class ClassInstance
@@ -257,6 +285,14 @@ module RBS
                        args: args.map {|ty| ty.sub(s) },
                        location: location)
       end
+
+      def map_type_name(&block)
+        ClassInstance.new(
+          name: yield(name, location, self),
+          args: args.map {|type| type.map_type_name(&block) },
+          location: location
+        )
+      end
     end
 
     class Alias
@@ -290,6 +326,13 @@ module RBS
       end
 
       include EmptyEachType
+
+      def map_type_name
+        Alias.new(
+          name: yield(name, location, self),
+          location: location
+        )
+      end
     end
 
     class Tuple
@@ -343,6 +386,13 @@ module RBS
           enum_for :each_type
         end
       end
+
+      def map_type_name(&block)
+        Tuple.new(
+          types: types.map {|type| type.map_type_name(&block) },
+          location: location
+        )
+      end
     end
 
     class Record
@@ -401,6 +451,13 @@ module RBS
           enum_for :each_type
         end
       end
+
+      def map_type_name(&block)
+        Record.new(
+          fields: fields.transform_values {|ty| ty.map_type_name(&block) },
+          location: location
+        )
+      end
     end
 
     class Optional
@@ -449,6 +506,13 @@ module RBS
           enum_for :each_type
         end
       end
+
+      def map_type_name(&block)
+        Optional.new(
+          type: type.map_type_name(&block),
+          location: location
+        )
+      end
     end
 
     class Union
@@ -510,6 +574,13 @@ module RBS
           enum_for :map_type
         end
       end
+
+      def map_type_name(&block)
+        Union.new(
+          types: types.map {|type| type.map_type_name(&block) },
+          location: location
+        )
+      end
     end
 
     class Intersection
@@ -572,6 +643,13 @@ module RBS
           enum_for :map_type
         end
       end
+
+      def map_type_name(&block)
+        Intersection.new(
+          types: types.map {|type| type.map_type_name(&block) },
+          location: location
+        )
+      end
     end
 
     class Function
@@ -648,7 +726,7 @@ module RBS
           other.required_keywords == required_keywords &&
           other.optional_keywords == optional_keywords &&
           other.rest_keywords == rest_keywords &&
-          return_type == return_type
+          other.return_type == return_type
       end
 
       alias eql? ==
@@ -710,6 +788,12 @@ module RBS
         end
       end
 
+      def map_type_name(&block)
+        map_type do |type|
+          type.map_type_name(&block)
+        end
+      end
+
       def each_type
         if block_given?
           required_positionals.each {|param| yield param.type }
@@ -899,6 +983,13 @@ module RBS
           enum_for :each_type
         end
       end
+
+      def map_type_name(&block)
+        Proc.new(
+          type: type.map_type_name(&block),
+          location: location
+        )
+      end
     end
 
     class Literal
@@ -923,6 +1014,7 @@ module RBS
       include NoFreeVariables
       include NoSubst
       include EmptyEachType
+      include NoTypeName
 
       def to_json(*a)
         { class: :literal, literal: literal.inspect, location: location }.to_json(*a)