rbs 0.2.0 → 0.6.0

data/lib/rbs/test/type_check.rb

@@ -4,9 +4,34 @@ module RBS
       attr_reader :self_class
       attr_reader :builder
 
-      def initialize(self_class:, builder:)
+      def initialize(self_class:, builder:, sampling:)
         @self_class = self_class
         @builder = builder
+        @sampling = sampling
+      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 +81,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 +176,14 @@ module RBS
         end
       end
 
+      def sampling?
+        !!@sampling
+      end
+
+      def sample(array)
+        array.size > 100 && sampling? ? array.sample(100) : array
+      end
+
       def value(val, type)
         case type
         when Types::Bases::Any
@@ -175,9 +208,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 +236,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 +258,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

data/lib/rbs/variance_calculator.rb

@@ -107,9 +107,19 @@ module RBS
           end
         end
       when Types::ClassInstance, Types::Interface
-        decl = env.find_class(type.name)
+        NoTypeFoundError.check!(type.name,
+                                env: env,
+                                location: type.location)
+
+        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
+
         type.args.each.with_index do |ty, i|
-          var = decl.type_params.params[i]
+          var = type_params.params[i]
           case var.variance
           when :invariant
             type(ty, result: result, context: :invariant)

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.2.0"
+  VERSION = "0.6.0"
 end

data/lib/rbs/writer.rb

@@ -1,37 +1,59 @@
 module RBS
   class Writer
     attr_reader :out
+    attr_reader :indentation
 
     def initialize(out:)
       @out = out
+      @indentation = []
     end
 
-    def write_annotation(annotations, level:)
-      prefix = " " * level
+    def indent(size = 2)
+      indentation.push(" " * size)
+      yield
+    ensure
+      indentation.pop
+    end
+
+    def prefix
+      indentation.join()
+    end
+
+    def puts(string = "")
+      if string.size > 0
+        @out.puts("#{prefix}#{string}")
+      else
+        @out.puts
+      end
+    end
 
+    def write_annotation(annotations)
       annotations.each do |annotation|
         string = annotation.string
         case
         when string !~ /\}/
-          out.puts "#{prefix}%a{#{string}}"
+          puts "%a{#{string}}"
         when string !~ /\)/
-          out.puts "#{prefix}%a(#{string})"
+          puts "%a(#{string})"
         when string !~ /\]/
-          out.puts "#{prefix}%a[#{string}]"
+          puts "%a[#{string}]"
         when string !~ /\>/
-          out.puts "#{prefix}%a<#{string}>"
+          puts "%a<#{string}>"
         when string !~ /\|/
-          out.puts "#{prefix}%a|#{string}|"
+          puts "%a|#{string}|"
         end
       end
     end
 
-    def write_comment(comment, level:)
+    def write_comment(comment)
       if comment
-        prefix = " " * level
         comment.string.lines.each do |line|
-          line = " #{line}" unless line.chomp.empty?
-          out.puts "#{prefix}##{line}"
+          line = line.chomp
+          unless line.empty?
+            puts "# #{line}"
+          else
+            puts "#"
+          end
         end
       end
     end
@@ -49,68 +71,72 @@ module RBS
         super_class = if decl.super_class
                         " < #{name_and_args(decl.super_class.name, decl.super_class.args)}"
                       end
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
+        write_comment decl.comment
+        write_annotation decl.annotations
+        puts "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
 
-        [nil, *decl.members].each_cons(2) do |prev, member|
-          preserve_empty_line prev, member
-          write_member member
+        indent do
+          [nil, *decl.members].each_cons(2) do |prev, member|
+            preserve_empty_line prev, member
+            write_member member
+          end
         end
 
-        out.puts "end"
+        puts "end"
 
       when AST::Declarations::Module
-        self_type = if decl.self_type
-                      " : #{decl.self_type}"
+        self_type = unless decl.self_types.empty?
+                      " : #{decl.self_types.join(", ")}"
                     end
 
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
-        decl.members.each.with_index do |member, index|
-          if index > 0
-            out.puts
+        write_comment decl.comment
+        write_annotation decl.annotations
+
+        puts "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
+
+        indent do
+          decl.members.each.with_index do |member, index|
+            if index > 0
+              puts
+            end
+            write_member member
           end
-          write_member member
         end
-        out.puts "end"
+
+        puts "end"
       when AST::Declarations::Constant
-        write_comment decl.comment, level: 0
-        out.puts "#{decl.name}: #{decl.type}"
+        write_comment decl.comment
+        puts "#{decl.name}: #{decl.type}"
 
       when AST::Declarations::Global
-        write_comment decl.comment, level: 0
-        out.puts "#{decl.name}: #{decl.type}"
+        write_comment decl.comment
+        puts "#{decl.name}: #{decl.type}"
 
       when AST::Declarations::Alias
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "type #{decl.name} = #{decl.type}"
+        write_comment decl.comment
+        write_annotation decl.annotations
+        puts "type #{decl.name} = #{decl.type}"
 
       when AST::Declarations::Interface
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "interface #{name_and_params(decl.name, decl.type_params)}"
-        decl.members.each.with_index do |member, index|
-          if index > 0
-            out.puts
+        write_comment decl.comment
+        write_annotation decl.annotations
+
+        puts "interface #{name_and_params(decl.name, decl.type_params)}"
+
+        indent do
+          decl.members.each.with_index do |member, index|
+            if index > 0
+              puts
+            end
+            write_member member
           end
-          write_member member
         end
-        out.puts "end"
+
+        puts "end"
 
       when AST::Declarations::Extension
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "extension #{name_and_args(decl.name, decl.type_params)} (#{decl.extension_name})"
-        decl.members.each.with_index do |member, index|
-          if index > 0
-            out.puts
-          end
-          write_member member
-        end
-        out.puts "end"
+        RBS.logger.warn "Extension is ignored: #{decl.name}"
+
       end
     end
 
@@ -151,52 +177,54 @@ module RBS
     def write_member(member)
       case member
       when AST::Members::Include
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  include #{name_and_args(member.name, member.args)}"
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "include #{name_and_args(member.name, member.args)}"
       when AST::Members::Extend
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  extend #{name_and_args(member.name, member.args)}"
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "extend #{name_and_args(member.name, member.args)}"
       when AST::Members::Prepend
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  prepend #{name_and_args(member.name, member.args)}"
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "prepend #{name_and_args(member.name, member.args)}"
       when AST::Members::AttrAccessor
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  #{attribute(:accessor, member)}"
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "#{attribute(:accessor, member)}"
       when AST::Members::AttrReader
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  #{attribute(:reader, member)}"
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "#{attribute(:reader, member)}"
       when AST::Members::AttrWriter
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  #{attribute(:writer, member)}"
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "#{attribute(:writer, member)}"
       when AST::Members::Public
-        out.puts "  public"
+        puts "public"
       when AST::Members::Private
-        out.puts "  private"
+        puts "private"
       when AST::Members::Alias
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
+        write_comment member.comment
+        write_annotation member.annotations
         new_name = member.singleton? ? "self.#{member.new_name}" : member.new_name
         old_name = member.singleton? ? "self.#{member.old_name}" : member.old_name
-        out.puts "  alias #{new_name} #{old_name}"
+        puts "alias #{new_name} #{old_name}"
       when AST::Members::InstanceVariable
-        write_comment member.comment, level: 2
-        out.puts "  #{member.name}: #{member.type}"
+        write_comment member.comment
+        puts "#{member.name}: #{member.type}"
       when AST::Members::ClassInstanceVariable
-        write_comment member.comment, level: 2
-        out.puts "  self.#{member.name}: #{member.type}"
+        write_comment member.comment
+        puts "self.#{member.name}: #{member.type}"
       when AST::Members::ClassVariable
-        write_comment member.comment, level: 2
-        out.puts "  #{member.name}: #{member.type}"
+        write_comment member.comment
+        puts "#{member.name}: #{member.type}"
       when AST::Members::MethodDefinition
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
+        write_comment member.comment
+        write_annotation member.annotations
         write_def member
+      else
+        write_decl member
       end
     end
 
@@ -220,18 +248,26 @@ module RBS
                "self.#{method_name(member.name)}"
              end
 
+      string = ""
+
       attrs = member.attributes.empty? ? "" : member.attributes.join(" ") + " "
-      prefix = "  #{attrs}def #{name}:"
+      overload = member.overload? ? "overload " : ""
+      prefix = "#{overload}#{attrs}def #{name}:"
       padding = " " * (prefix.size-1)
 
-      out.print prefix
+      string << prefix
 
       member.types.each.with_index do |type, index|
         if index > 0
-          out.print padding
-          out.print "|"
+          string << padding
+          string << "|"
         end
-        out.puts " #{type}"
+
+        string << " #{type}\n"
+      end
+
+      string.each_line do |line|
+        puts line.chomp
       end
     end
 
@@ -255,14 +291,14 @@ module RBS
       # When the signature is not constructed by the parser,
       # it always inserts an empty line.
       if !prev.location || !decl.location
-        out.puts
+        puts
         return
       end
 
       prev_end_line = prev.location.end_line
       start_line = decl.location.start_line
       if start_line - prev_end_line > 1
-        out.puts
+        puts
       end
     end
   end