rbs 3.5.3 → 3.6.0.pre.1

data/lib/rbs/errors.rb

@@ -35,7 +35,7 @@ module RBS
       return msg unless location.start_line == location.end_line
 
       indent = " " * location.start_column
-      marker = "^" * (location.end_column - location.start_column)
+      marker = "^" * ([location.end_column - location.start_column, 1].max or raise)
 
       io = StringIO.new
       io.puts msg
@@ -68,18 +68,23 @@ module RBS
     attr_reader :type_name
     attr_reader :args
     attr_reader :params
+    attr_reader :type_params
     attr_reader :location
 
     def initialize(type_name:, args:, params:, location:)
       @type_name = type_name
       @args = args
-      @params = params
+      @type_params = params
+      @params = params.map(&:name)
       @location = location
       super "#{Location.to_string location}: #{type_name} expects parameters [#{params.join(", ")}], but given args [#{args.join(", ")}]"
     end
 
     def self.check!(type_name:, args:, params:, location:)
-      unless args.size == params.size
+      min_arity = params.count { _1.default_type.nil? }
+      max_arity = params.size
+
+      unless min_arity <= args.size && args.size <= max_arity
         raise new(type_name: type_name, args: args, params: params, location: location)
       end
     end

data/lib/rbs/file_finder.rb

@@ -4,27 +4,24 @@ module RBS
   module FileFinder
     module_function
 
-    def self.each_file(path, immediate:, skip_hidden:, &block)
+    def self.each_file(path, immediate: nil, skip_hidden:, &block)
       return enum_for((__method__ or raise), path, immediate: immediate, skip_hidden: skip_hidden) unless block
 
       case
       when path.file?
-        if path.extname == ".rbs" || immediate
-          yield path
-        end
+        yield path
 
       when path.directory?
-        if path.basename.to_s.start_with?("_")
-          if skip_hidden
-            unless immediate
-              return
-            end
+        paths = Pathname.glob("#{path}/**/*.rbs")
+
+        if skip_hidden
+          paths.select! do |child|
+            child.relative_path_from(path).ascend.drop(1).none? { _1.basename.to_s.start_with?("_") }
           end
         end
+        paths.sort_by!(&:to_s)
 
-        path.children.sort.each do |child|
-          each_file(child, immediate: false, skip_hidden: skip_hidden, &block)
-        end
+        paths.each(&block)
       end
     end
   end

data/lib/rbs/location_aux.rb

@@ -49,15 +49,11 @@ module RBS
     end
 
     def start_loc
-      @start_loc ||= begin
-        _start_loc || buffer.pos_to_loc(start_pos)
-      end
+      @start_loc ||= buffer.pos_to_loc(start_pos)
     end
 
     def end_loc
-      @end_loc ||= begin
-        _end_loc || buffer.pos_to_loc(end_pos)
-      end
+      @end_loc ||= buffer.pos_to_loc(end_pos)
     end
 
     def range

data/lib/rbs/locator.rb

@@ -171,13 +171,16 @@ module RBS
       if test_loc(pos, location: type_param.location)
         array.unshift(type_param)
 
-        if upper_bound = type_param.upper_bound
-          find_in_type(pos, type: upper_bound, array: array) or
-            find_in_loc(pos, location: type_param.location, array: array)
-        else
-          find_in_loc(pos, location: type_param.location, array: array)
+        if upper_bound = type_param.upper_bound_type
+          find_in_type(pos, type: upper_bound, array: array) and return true
         end
 
+        if default_type = type_param.default_type
+          find_in_type(pos, type: default_type, array: array) and return true
+        end
+
+        find_in_loc(pos, location: type_param.location, array: array)
+
         true
       else
         false

data/lib/rbs/prototype/rbi.rb

@@ -236,7 +236,8 @@ module RBS
                 name: node.children[0],
                 variance: variance || :invariant,
                 location: nil,
-                upper_bound: nil
+                upper_bound: nil,
+                default_type: nil
               )
             end
           else

data/lib/rbs/prototype/runtime.rb

@@ -332,8 +332,6 @@ module RBS
 
         public_instance_methods = mod.public_instance_methods.select {|name| target_method?(mod, instance: name) }
         unless public_instance_methods.empty?
-          members << AST::Members::Public.new(location: nil)
-
           public_instance_methods.sort.each do |name|
             method = mod.instance_method(name)
             next if todo_object&.skip_instance_method?(module_name: module_name_absolute, method: method, accessibility: :public)
@@ -656,6 +654,9 @@ module RBS
           ast = RubyVM::AbstractSyntaxTree.of(method)
         rescue ArgumentError
           return # When the method is defined in eval
+        rescue RuntimeError => error
+          raise unless error.message.include?("prism")
+          return # When the method was compiled by prism
         end
 
         if ast && ast.type == :SCOPE

data/lib/rbs/sorter.rb

@@ -17,18 +17,18 @@ module RBS
       buffer = Buffer.new(name: path, content: path.read)
       _, _, sigs = Parser.parse_signature(buffer)
 
-      sigs.each do |m|
-        sort_decl! m
+      sigs = sigs.map do |m|
+        sort_decl m
       end
 
       stdout.puts "Writing #{path}..."
       path.open('w') do |out|
         writer = RBS::Writer.new(out: out)
-        writer.write sigs
+        writer.write _ = sigs
       end
     end
 
-    def sort_decl!(decl)
+    def sort_decl(decl)
       case decl
       when Declarations::Class, Declarations::Module, Declarations::Interface
         partitioned = {
@@ -52,7 +52,8 @@ module RBS
           private_instance_methods: [],
         } #: partitioned
 
-        decl.members.each { |m| sort_decl! m }
+        members = decl.members.map { |m| sort_decl m }
+        decl = decl.update(members: _ = members)
 
         visibility_annotated_members = [] #: Array[member]
 
@@ -188,7 +189,9 @@ module RBS
 
         members.push(*partitioned[:other_decls])
 
-        decl.members.replace(_ = members)
+        decl.update(members: _ = members)
+      else
+        decl
       end
     end
   end

data/lib/rbs/test/type_check.rb

@@ -59,6 +59,8 @@ module RBS
       end
 
       def method_call(method_name, method_type, call, errors:)
+        return errors if method_type.type.is_a?(Types::UntypedFunction)
+
         args(method_name, method_type, method_type.type, call.method_call, errors, type_error: Errors::ArgumentTypeError, argument_error: Errors::ArgumentError)
         self.return(method_name, method_type, method_type.type, call.method_call, errors, return_error: Errors::ReturnTypeError)
 
@@ -150,6 +152,8 @@ module RBS
       end
 
       def zip_args(args, fun, &block)
+        return true if fun.is_a?(Types::UntypedFunction)
+
         case
         when args.empty?
           if fun.required_positionals.empty? && fun.trailing_positionals.empty? && fun.required_keywords.empty?
@@ -256,6 +260,13 @@ module RBS
           Test.call(val, IS_AP, instance_class)
         when Types::ClassInstance
           klass = get_class(type.name) or return false
+          if params = builder.env.normalized_module_class_entry(type.name.absolute!)&.type_params
+            args = AST::TypeParam.normalize_args(params, type.args)
+            unless args == type.args
+              type = Types::ClassInstance.new(name: type.name, args: args, location: type.location)
+            end
+          end
+
           case
           when klass == ::Array
             Test.call(val, IS_AP, klass) && each_sample(val).all? {|v| value(v, type.args[0]) }
@@ -355,6 +366,8 @@ module RBS
         fun = method_type.type
         take_has_rest = !!parameters.find { |(op, _)| op == :rest }
 
+        return true if fun.is_a?(Types::UntypedFunction)
+
         fun.required_positionals.each do
           op, _ = parameters.first
           return false if op.nil? || op == :keyreq || op == :key || op == :keyrest

data/lib/rbs/types.rb

@@ -1278,6 +1278,17 @@ module RBS
       def return_to_s
         return_type.to_s(1)
       end
+
+      def ==(other)
+        other.is_a?(UntypedFunction) && other.return_type == return_type
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ return_type.hash
+      end
+
     end
 
     class Block

data/lib/rbs/validator.rb

@@ -43,7 +43,7 @@ module RBS
           InvalidTypeApplicationError.check!(
             type_name: type.name,
             args: type.args,
-            params: type_params.each.map(&:name),
+            params: type_params,
             location: type.location
           )
         end
@@ -125,7 +125,7 @@ module RBS
       # @type var each_child: ^(Symbol) { (Symbol) -> void } -> void
       each_child = -> (name, &block) do
         if param = params.find {|p| p.name == name }
-          if b = param.upper_bound
+          if b = param.upper_bound_type
             b.free_variables.each do |tv|
               block[tv]
             end

data/lib/rbs/vendorer.rb

@@ -31,7 +31,7 @@ module RBS
 
       if core_root = loader.core_root
         RBS.logger.info "Vendoring core RBSs in #{vendor_dir + "core"}..."
-        FileFinder.each_file(core_root, immediate: false, skip_hidden: true) do |file_path|
+        FileFinder.each_file(core_root, skip_hidden: true) do |file_path|
           paths << [file_path, Pathname("core") + file_path.relative_path_from(core_root)]
         end
       end
@@ -43,7 +43,7 @@ module RBS
 
           RBS.logger.info "Vendoring #{lib.name}(#{spec.version}) RBSs in #{vendor_dir + dest_dir}..."
 
-          FileFinder.each_file(path, skip_hidden: true, immediate: false) do |file_path|
+          FileFinder.each_file(path, skip_hidden: true) do |file_path|
             paths << [file_path, dest_dir + file_path.relative_path_from(path)]
           end
 
@@ -52,7 +52,7 @@ module RBS
 
           RBS.logger.info "Vendoring #{lib.name}(#{path.version}) RBSs in #{vendor_dir + dest_dir}..."
 
-          FileFinder.each_file(path.path, skip_hidden: true, immediate: false) do |file_path|
+          FileFinder.each_file(path.path, skip_hidden: true) do |file_path|
             paths << [file_path, dest_dir + file_path.relative_path_from(path.path)]
           end
         else

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.5.3"
+  VERSION = "3.6.0.pre.1"
 end

data/lib/rbs.rb

@@ -22,6 +22,7 @@ require "rbs/ast/directives"
 require "rbs/ast/declarations"
 require "rbs/ast/members"
 require "rbs/ast/annotation"
+require "rbs/ast/visitor"
 require "rbs/environment"
 require "rbs/environment/use_map"
 require "rbs/environment_loader"

data/sig/declarations.rbs

@@ -77,6 +77,8 @@ module RBS
 
         def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], super_class: Super?, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
+        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?super_class: Super?, ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?) -> Declarations::Class
+
         include _HashEqual
         include _ToJson
       end
@@ -131,6 +133,8 @@ module RBS
 
         def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], location: loc?, annotations: Array[Annotation], self_types: Array[Self], comment: Comment?) -> void
 
+        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?location: loc?, ?annotations: Array[Annotation], ?self_types: Array[Self], ?comment: Comment?) -> Declarations::Module
+
         include _HashEqual
         include _ToJson
       end
@@ -160,6 +164,8 @@ module RBS
 
         def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
+        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?) -> Declarations::Interface
+
         include MixinHelper
 
         include _HashEqual

data/sig/definition.rbs

@@ -66,7 +66,7 @@ module RBS
       #
       def map_type: () { (Types::t) -> Types::t } -> Method
 
-      def map_type_bound: () { (AST::TypeParam::bound) -> AST::TypeParam::bound } -> Method
+      def map_type_bound: () { (Types::t) -> Types::t } -> Method
 
       def map_method_type: () { (MethodType) -> MethodType } -> Method
 

data/sig/definition_builder.rbs

@@ -116,6 +116,7 @@ module RBS
       Definition class_definition,
       MethodBuilder::Methods::Definition method_definition,
       Substitution subst,
+      Hash[Symbol, Definition::Method]? self_type_methods,
       defined_in: TypeName,
       ?implemented_in: TypeName?
     ) -> void
@@ -137,7 +138,8 @@ module RBS
       TypeName module_name,
       MethodBuilder::Methods module_methods,
       interface_methods interface_methods,
-      Substitution subst
+      Substitution subst,
+      Hash[Symbol, Definition::Method]? self_type_methods,
     ) -> void
 
     # Updates `definition` with methods and variables of `type_name` that can be a module or a class

data/sig/errors.rbs

@@ -60,11 +60,12 @@ module RBS
     attr_reader type_name: TypeName
     attr_reader args: Array[Types::t]
     attr_reader params: Array[Symbol]
+    attr_reader type_params: Array[AST::TypeParam]
     attr_reader location: Location[untyped, untyped]?
 
-    def initialize: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location[untyped, untyped]?) -> void
+    def initialize: (type_name: TypeName, args: Array[Types::t], params: Array[AST::TypeParam], location: Location[untyped, untyped]?) -> void
 
-    def self.check!: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location[untyped, untyped]?) -> void
+    def self.check!: (type_name: TypeName, args: Array[Types::t], params: Array[AST::TypeParam], location: Location[untyped, untyped]?) -> void
   end
 
   class RecursiveAncestorError < DefinitionError

data/sig/file_finder.rbs

@@ -1,6 +1,28 @@
 module RBS
   module FileFinder
-    def self?.each_file: (Pathname path, immediate: boolish, skip_hidden: boolish) { (Pathname) -> void } -> void
-                        | (Pathname path, immediate: boolish, skip_hidden: boolish) -> Enumerator[Pathname, void]
+    # Enumerate RBS files under path
+    #
+    # When `path` is a file, it yields the path.
+    #
+    # ```rb
+    # FileFinder.each_file(Pathname("foo.rbs")) {} # => yields `foo.rbs`
+    # ```
+    #
+    # When `path` is a directory, it yields all `.rbs` files under the directory, recursively.
+    #
+    # * Skips files under directory starting with `_`, if `skip_hidden` is `true`
+    # * Yields files under directory starting with `_` even if `skip_hidden` is true, when the `_` directory is given explicitly, and `immediate:` is `true`
+    #
+    # ```rb
+    # FileFinder.each_file(Pathname("sig"), skip_hidden: false) {} # => yields all `.rbs` files under `sig`
+    # FileFinder.each_file(Pathname("sig"), skip_hidden: true) {} # => yields all `.rbs` files under `sig`, skips `_` directories
+    #
+    # FileFinder.each_file(Pathname("_hidden"), skip_hidden: true) {}  # => yields all `.rbs` files under `_hidden`, skips other `_` directories
+    # ```
+    #
+    # `immediate` keyword is unused and left for API compatibility.
+    # 
+    def self?.each_file: (Pathname path, ?immediate: top, skip_hidden: boolish) { (Pathname) -> void } -> void
+                        | (Pathname path, ?immediate: top, skip_hidden: boolish) -> Enumerator[Pathname, void]
   end
 end

data/sig/location.rbs

@@ -99,9 +99,6 @@ module RBS
 
     private
 
-    def _start_loc: () -> Buffer::loc?
-    def _end_loc: () -> Buffer::loc?
-
     def _add_required_child: (RequiredChildKeys name, Integer start_pos, Integer end_pos) -> void
     def _add_optional_child: (OptionalChildKeys name, Integer start_pos, Integer end_pos) -> void
     def _add_optional_no_child: (OptionalChildKeys name) -> void

data/sig/method_types.rbs

@@ -40,7 +40,7 @@ module RBS
     #
     def map_type: () { (Types::t) -> Types::t } -> MethodType
 
-    def map_type_bound: () { (AST::TypeParam::bound) -> AST::TypeParam::bound } -> MethodType
+    def map_type_bound: () { (Types::t) -> Types::t } -> MethodType
 
     def each_type: () { (Types::t) -> void } -> void
                  | () -> Enumerator[Types::t, void]

data/sig/sorter.rbs

@@ -36,6 +36,6 @@ module RBS
       other_decls: Array[member]
     }
 
-    def sort_decl!: (member decl) -> void
+    def sort_decl: (member decl) -> member
   end
 end

data/sig/type_param.rbs

@@ -4,12 +4,13 @@ module RBS
       # Key
       # ^^^ name
       #
-      # unchecked out Elem < _ToJson
-      # ^^^^^^^^^                    unchecked
-      #           ^^^                variance
-      #               ^^^^           name
-      #                    ^^^^^^^^^ upper_bound
-      type loc = Location[:name, :variance | :unchecked | :upper_bound]
+      # unchecked out Elem < _ToJson = untyped
+      # ^^^^^^^^^                                 unchecked
+      #           ^^^                             variance
+      #               ^^^^                        name
+      #                    ^^^^^^^^^              upper_bound
+      #                              ^^^^^^^^^    default
+      type loc = Location[:name, :variance | :unchecked | :upper_bound | :default]
 
       type variance = :invariant | :covariant | :contravariant
 
@@ -19,9 +20,13 @@ module RBS
       attr_reader variance: variance
       attr_reader location: loc?
 
-      attr_reader upper_bound: bound?
+      %a{pure} def upper_bound: () -> bound?
 
-      def initialize: (name: Symbol, variance: variance, upper_bound: bound?, location: loc?) -> void
+      attr_reader upper_bound_type: Types::t?
+
+      attr_reader default_type: Types::t?
+
+      def initialize: (name: Symbol, variance: variance, upper_bound: Types::t?, location: loc?, ?default_type: Types::t?) -> void
 
       include _ToJson
 
@@ -37,7 +42,7 @@ module RBS
 
       def unchecked?: () -> bool
 
-      def map_type: () { (bound) -> bound } -> TypeParam
+      def map_type: () { (Types::t) -> Types::t } -> TypeParam
 
       # Helper function to resolve _class instance types_ to _type variables_.
       #
@@ -69,6 +74,33 @@ module RBS
       def self.rename: (Array[TypeParam], new_names: Array[Symbol]) -> Array[TypeParam]
 
       def to_s: () -> String
+
+      # Returns an application with respect to type params` default
+      #
+      def self.application: (Array[TypeParam], Array[Types::t]) -> Substitution?
+
+      # Returns an array of type args, that fills ommited types with the defaults
+      #
+      # ```rbs
+      # interface _Foo[T, S = untyped]
+      # end
+      # ```
+      #
+      # Normalizing type args with `_Foo` works as following:
+      #
+      # ```rbs
+      # _Foo[String]                   # => _Foo[String, untyped]
+      # _Foo[String, Integer]          # => _Foo[String, Integer]
+      # _Foo                           # => _Foo                            (Omitting missing args)
+      # _Foo[String, Integer, untyped] # => _Foo[String, Integer, untyped]  (Keeping extra args)
+      # ```
+      #
+      # Note that it allows iinvalid arities.
+      #
+      # * Missing args will be omitted
+      # * Extra args will be keeped
+      #
+      def self.normalize_args: (Array[TypeParam], Array[Types::t]) -> Array[Types::t]
     end
   end
 end

data/sig/types.rbs

@@ -446,6 +446,12 @@ module RBS
       def has_classish_type?: () -> bool
 
       def with_nonreturn_void?: () -> bool
+
+      def ==: (untyped) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
     end
 
     # Function type without type checking arguments
@@ -489,6 +495,12 @@ module RBS
 
       # Returns `return_type.to_s(1)`
       def return_to_s: () -> String
+
+      def ==: (untyped) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
     end
 
     type function = Types::Function | Types::UntypedFunction

data/sig/visitor.rbs

@@ -0,0 +1,47 @@
+module RBS
+  module AST
+    class Visitor
+      def visit_all: (Enumerable[(Members::Base | Declarations::Base)] nodes) -> void
+
+      def visit: ((Members::Base | Declarations::Base) node) -> void
+
+      def visit_declaration_global: (Declarations::Global node) -> void
+
+      def visit_declaration_class: (Declarations::Class node) -> void
+
+      def visit_declaration_module: (Declarations::Module node) -> void
+
+      def visit_declaration_constant: (Declarations::Constant node) -> void
+
+      def visit_declaration_type_alias: (Declarations::TypeAlias node) -> void
+
+      def visit_declaration_interface: (Declarations::Interface node) -> void
+
+      def visit_member_alias: (Members::Alias node) -> void
+
+      def visit_member_class_instance_variable: (Members::ClassInstanceVariable node) -> void
+
+      def visit_member_class_variable: (Members::ClassVariable node) -> void
+
+      def visit_member_instance_variable: (Members::InstanceVariable node) -> void
+
+      def visit_member_private: (Members::Private node) -> void
+
+      def visit_member_public: (Members::Public node) -> void
+
+      def visit_member_method_definition: (Members::MethodDefinition node) -> void
+
+      def visit_member_attr_reader: (Members::AttrReader node) -> void
+
+      def visit_member_attr_writer: (Members::AttrWriter node) -> void
+
+      def visit_member_attr_accessor: (Members::AttrAccessor node) -> void
+
+      def visit_member_include: (Members::Include node) -> void
+
+      def visit_member_prepend: (Members::Prepend node) -> void
+
+      def visit_member_extend: (Members::Extend node) -> void
+    end
+  end
+end