rbs 0.4.0 → 0.5.0

data/lib/rbs/prototype/rbi.rb

@@ -173,7 +173,8 @@ module RBS
               types: types,
               kind: :singleton,
               comment: comment,
-              attributes: []
+              attributes: [],
+              overload: false
             )
           end
 
@@ -193,7 +194,8 @@ module RBS
               types: types,
               kind: :instance,
               comment: comment,
-              attributes: []
+              attributes: [],
+              overload: false
             )
           end
 

data/lib/rbs/prototype/runtime.rb

@@ -128,7 +128,7 @@ module RBS
 
       def merge_rbs(module_name, members, instance: nil, singleton: nil)
         if merge
-          if env.class?(module_name.absolute!)
+          if env.class_decls[module_name.absolute!]
             case
             when instance
               method = builder.build_instance(module_name.absolute!).methods[instance]
@@ -152,9 +152,10 @@ module RBS
                 },
                 kind: kind,
                 location: nil,
-                comment: method.comment,
+                comment: method.comments[0],
                 annotations: method.annotations,
-                attributes: method.attributes
+                attributes: method.attributes,
+                overload: false
               )
               return
             end
@@ -192,7 +193,8 @@ module RBS
                 location: nil,
                 comment: nil,
                 annotations: [],
-                attributes: []
+                attributes: [],
+                overload: false
               )
             end
           else
@@ -225,7 +227,8 @@ module RBS
                   location: nil,
                   comment: nil,
                   annotations: [],
-                  attributes: []
+                  attributes: [],
+                  overload: false
                 )
               end
             else
@@ -259,7 +262,8 @@ module RBS
                   location: nil,
                   comment: nil,
                   annotations: [],
-                  attributes: []
+                  attributes: [],
+                  overload: false
                 )
               end
             else

data/lib/rbs/substitution.rb

@@ -1,6 +1,7 @@
 module RBS
   class Substitution
     attr_reader :mapping
+    attr_accessor :instance_type
 
     def initialize()
       @mapping = {}
@@ -10,7 +11,7 @@ module RBS
       mapping[from] = to
     end
 
-    def self.build(variables, types, &block)
+    def self.build(variables, types, instance_type: Types::Bases::Instance.new(location: nil), &block)
       unless variables.size == types.size
         raise "Broken substitution: variables=#{variables}, types=#{types}"
       end
@@ -22,6 +23,8 @@ module RBS
           type = block_given? ? yield(t) : t
           subst.add(from: v, to: type)
         end
+
+        subst.instance_type = instance_type
       end
     end
 
@@ -29,6 +32,8 @@ module RBS
       case ty
       when Types::Variable
         mapping[ty.name] || ty
+      when Types::Bases::Instance
+        instance_type
       else
         ty
       end
@@ -40,6 +45,8 @@ module RBS
         vars.each do |var|
           subst.mapping.delete(var)
         end
+
+        subst.instance_type = self.instance_type
       end
     end
   end

data/lib/rbs/test/hook.rb

@@ -94,7 +94,7 @@ module RBS
 
         builder.build_instance(type_name).tap do |definition|
           definition.methods.each do |name, method|
-            if method.defined_in.name.absolute! == type_name
+            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
@@ -107,7 +107,7 @@ module RBS
 
         builder.build_singleton(type_name).tap do |definition|
           definition.methods.each do |name, method|
-            if method.defined_in&.name&.absolute! == type_name || name == :new
+            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

data/lib/rbs/test/setup.rb

@@ -33,6 +33,8 @@ OptionParser.new do |opts|
 end.parse!(opts)
 loader.load(env: env)
 
+env = env.resolve_type_names
+
 def match(filter, name)
   if filter.end_with?("*")
     name.start_with?(filter[0, filter.size - 1]) || name == filter[0, filter.size-3]
@@ -48,7 +50,7 @@ TracePoint.trace :end do |tp|
     if filter.any? {|f| match(f, class_name) } && skips.none? {|f| match(f, class_name) }
       type_name = RBS::Namespace.parse(class_name).absolute!.to_type_name
       if hooks.none? {|hook| hook.klass == tp.self }
-        if env.find_class(type_name)
+        if env.class_decls.key?(type_name)
           logger.info "Setting up hooks for #{class_name}"
           hooks << RBS::Test::Hook.install(env, tp.self, logger: logger).verify_all.raise_on_error!(raise_on_error)
         end

data/lib/rbs/test/test_helper.rb

@@ -17,9 +17,7 @@ module RBS
                        loader.add library: lib
                      end
 
-                     RBS::Environment.new.tap do |env|
-                       loader.load(env: env)
-                     end
+                     RBS::Environment.from_loader(loader).resolve_type_names
                    end
         end
 
@@ -126,8 +124,7 @@ module RBS
         type, definition = target
         method_types = case
                        when definition.instance_type?
-                         subst = Substitution.build(definition.declaration.type_params.each.map(&:name),
-                                                    type.args)
+                         subst = Substitution.build(definition.type_params, type.args)
                          definition.methods[method].method_types.map do |method_type|
                            method_type.sub(subst)
                          end

data/lib/rbs/test/type_check.rb

@@ -220,8 +220,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)

data/lib/rbs/validator.rb

@@ -0,0 +1,51 @@
+module RBS
+  class Validator
+    attr_reader :env
+    attr_reader :resolver
+
+    def initialize(env:, resolver:)
+      @env = env
+      @resolver = resolver
+    end
+
+    def absolute_type(type, context:)
+      type.map_type_name do |type_name, _, type|
+        resolver.resolve(type_name, context: context) || yield(type)
+      end
+    end
+
+    # Validates presence of the relative type, and application arity match.
+    def validate_type(type, context:)
+      case type
+      when Types::ClassInstance, Types::Interface
+        if type.name.namespace.relative?
+          type = absolute_type(type, context: context) do |type|
+            NoTypeFoundError.check!(type.name.absolute!, env: env, location: type.location)
+          end
+        end
+
+        type_params = case type
+                      when Types::ClassInstance
+                        env.class_decls[type.name]&.type_params
+                      when Types::Interface
+                        env.interface_decls[type.name]&.decl&.type_params
+                      end
+
+        unless type_params
+          raise NoTypeFoundError.new(type_name: type.name, location: type.location)
+        end
+
+        InvalidTypeApplicationError.check!(
+          type_name: type.name,
+          args: type.args,
+          params: type_params.each.map(&:name),
+          location: type.location
+        )
+      end
+
+      type.each_type do |type|
+        validate_type(type, context: context)
+      end
+    end
+  end
+end