rbs 3.5.3 → 3.6.0.pre.1

data/lib/rbs/ast/type_param.rb

@@ -3,14 +3,22 @@
 module RBS
   module AST
     class TypeParam
-      attr_reader :name, :variance, :location, :upper_bound
+      attr_reader :name, :variance, :location, :upper_bound_type, :default_type
 
-      def initialize(name:, variance:, upper_bound:, location:)
+      def initialize(name:, variance:, upper_bound:, location:, default_type: nil)
         @name = name
         @variance = variance
-        @upper_bound = upper_bound
+        @upper_bound_type = upper_bound
         @location = location
         @unchecked = false
+        @default_type = default_type
+      end
+
+      def upper_bound
+        case upper_bound_type
+        when Types::ClassInstance, Types::ClassSingleton, Types::Interface
+          upper_bound_type
+        end
       end
 
       def unchecked!(value = true)
@@ -26,14 +34,15 @@ module RBS
         other.is_a?(TypeParam) &&
           other.name == name &&
           other.variance == variance &&
-          other.upper_bound == upper_bound &&
+          other.upper_bound_type == upper_bound_type &&
+          other.default_type == default_type &&
           other.unchecked? == unchecked?
       end
 
       alias eql? ==
 
       def hash
-        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound.hash ^ unchecked?.hash
+        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound_type.hash ^ unchecked?.hash ^ default_type.hash
       end
 
       def to_json(state = JSON::State.new)
@@ -42,7 +51,8 @@ module RBS
           variance: variance,
           unchecked: unchecked?,
           location: location,
-          upper_bound: upper_bound
+          upper_bound: upper_bound_type,
+          default_type: default_type
         }.to_json(state)
       end
 
@@ -50,21 +60,27 @@ module RBS
         TypeParam.new(
           name: name,
           variance: variance,
-          upper_bound: upper_bound,
-          location: location
+          upper_bound: upper_bound_type,
+          location: location,
+          default_type: default_type
         ).unchecked!(unchecked?)
       end
 
       def map_type(&block)
-        if b = upper_bound
-          _upper_bound = yield(b)
+        if b = upper_bound_type
+          _upper_bound_type = yield(b)
+        end
+
+        if dt = default_type
+          _default_type = yield(dt)
         end
 
         TypeParam.new(
           name: name,
           variance: variance,
-          upper_bound: _upper_bound,
-          location: location
+          upper_bound: _upper_bound_type,
+          location: location,
+          default_type: _default_type
         ).unchecked!(unchecked?)
       end
 
@@ -101,8 +117,9 @@ module RBS
           TypeParam.new(
             name: new_name,
             variance: param.variance,
-            upper_bound: param.upper_bound&.map_type {|type| type.sub(subst) },
-            location: param.location
+            upper_bound: param.upper_bound_type&.map_type {|type| type.sub(subst) },
+            location: param.location,
+            default_type: param.default_type&.map_type {|type| type.sub(subst) }
           ).unchecked!(param.unchecked?)
         end
       end
@@ -125,12 +142,51 @@ module RBS
 
         s << name.to_s
 
-        if type = upper_bound
+        if type = upper_bound_type
           s << " < #{type}"
         end
 
+        if dt = default_type
+          s << " = #{dt}"
+        end
+
         s
       end
+
+      def self.application(params, args)
+        subst = Substitution.new()
+
+        if params.empty?
+          return nil
+        end
+
+        min_count = params.count { _1.default_type.nil? }
+        max_count = params.size
+
+        unless min_count <= args.size && args.size <= max_count
+          raise "Invalid type application: required type params=#{min_count}, optional type params=#{max_count - min_count}, given args=#{args.size}"
+        end
+
+        params.zip(args).each do |param, arg|
+          if arg
+            subst.add(from: param.name, to: arg)
+          else
+            subst.add(from: param.name, to: param.default_type || raise)
+          end
+        end
+
+        subst
+      end
+
+      def self.normalize_args(params, args)
+        params.zip(args).filter_map do |param, arg|
+          if arg
+            arg
+          else
+            param.default_type
+          end
+        end
+      end
     end
   end
 end

data/lib/rbs/ast/visitor.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    # The Visitor class implements the Visitor pattern for traversing the RBS Abstract Syntax Tree (AST).
+    #
+    # It provides methods to visit each type of node in the AST, allowing for custom processing of each node type.
+    #
+    # This class is designed to be subclassed, with specific visit methods overridden to implement custom behavior for
+    # different node types.
+    #
+    # Example usage:
+    #
+    # ~~~rb
+    # class MyVisitor < RBS::AST::Visitor
+    #   def visit_declaration_class(node)
+    #     puts "Visiting class: #{node.name}"
+    #
+    #     super # call `super` to run the default visiting behavior
+    #   end
+    # end
+    #
+    # visitor = MyVisitor.new
+    # visitor.visit(ast_node)
+    # ~~~
+    class Visitor
+      def visit(node)
+        case node
+        when Declarations::Global
+          visit_declaration_global(node)
+        when Declarations::Class
+          visit_declaration_class(node)
+        when Declarations::Module
+          visit_declaration_module(node)
+        when Declarations::Constant
+          visit_declaration_constant(node)
+        when Declarations::TypeAlias
+          visit_declaration_type_alias(node)
+        when Declarations::Interface
+          visit_declaration_interface(node)
+        when Members::Alias
+          visit_member_alias(node)
+        when Members::ClassInstanceVariable
+          visit_member_class_instance_variable(node)
+        when Members::ClassVariable
+          visit_member_class_variable(node)
+        when Members::InstanceVariable
+          visit_member_instance_variable(node)
+        when Members::Private
+          visit_member_private(node)
+        when Members::Public
+          visit_member_public(node)
+        when Members::MethodDefinition
+          visit_member_method_definition(node)
+        when Members::AttrReader
+          visit_member_attr_reader(node)
+        when Members::AttrWriter
+          visit_member_attr_writer(node)
+        when Members::AttrAccessor
+          visit_member_attr_accessor(node)
+        when Members::Include
+          visit_member_include(node)
+        when Members::Prepend
+          visit_member_prepend(node)
+        when Members::Extend
+          visit_member_extend(node)
+        end
+      end
+
+      def visit_all(nodes)
+        nodes.each do |node|
+          visit(node)
+        end
+      end
+
+      def visit_declaration_global(node)
+      end
+
+      def visit_declaration_class(node)
+        visit_all(node.members)
+      end
+
+      def visit_declaration_module(node)
+        visit_all(node.members)
+      end
+
+      def visit_declaration_constant(node)
+      end
+
+      def visit_declaration_type_alias(node)
+      end
+
+      def visit_declaration_interface(node)
+        visit_all(node.members)
+      end
+
+      def visit_member_alias(node)
+      end
+
+      def visit_member_class_instance_variable(node)
+      end
+
+      def visit_member_class_variable(node)
+      end
+
+      def visit_member_instance_variable(node)
+      end
+
+      def visit_member_private(node)
+      end
+
+      def visit_member_public(node)
+      end
+
+      def visit_member_method_definition(node)
+      end
+
+      def visit_member_attr_reader(node)
+      end
+
+      def visit_member_attr_writer(node)
+      end
+
+      def visit_member_attr_accessor(node)
+      end
+
+      def visit_member_include(node)
+      end
+
+      def visit_member_prepend(node)
+      end
+
+      def visit_member_extend(node)
+      end
+    end
+  end
+end

data/lib/rbs/buffer.rb

@@ -25,6 +25,11 @@ module RBS
             @ranges << range
             offset += size
           end
+
+          if !content.end_with?("\n") && content.size > 0
+            @ranges[-1] = @ranges[-1].begin...(@ranges[-1].end+1)
+          end
+
           @ranges
         end
     end

data/lib/rbs/cli/validate.rb

@@ -94,7 +94,7 @@ EOU
       private
 
       def validate_class_module_definition
-        @env.class_decls.each do |name, decl|
+        @env.class_decls.each do |name, entry|
           RBS.logger.info "Validating class/module definition: `#{name}`..."
           @builder.build_instance(name).each_type do |type|
             @validator.validate_type type, context: nil
@@ -107,30 +107,47 @@ EOU
             @errors.add(error)
           end
 
-          case decl
+          case entry
           when Environment::ClassEntry
-            decl.decls.each do |decl|
+            entry.decls.each do |decl|
               if super_class = decl.decl.super_class
                 super_class.args.each do |arg|
                   void_type_context_validator(arg, true)
                   no_self_type_validator(arg)
                   no_classish_type_validator(arg)
+                  @validator.validate_type(arg, context: nil)
+                end
+
+                if super_entry = @env.normalized_class_entry(super_class.name)
+                  InvalidTypeApplicationError.check!(type_name: super_class.name, args: super_class.args, params: super_entry.type_params, location: super_class.location)
                 end
               end
             end
           when Environment::ModuleEntry
-            decl.decls.each do |decl|
+            entry.decls.each do |decl|
               decl.decl.self_types.each do |self_type|
                 self_type.args.each do |arg|
                   void_type_context_validator(arg, true)
                   no_self_type_validator(arg)
                   no_classish_type_validator(arg)
+                  @validator.validate_type(arg, context: nil)
+                end
+
+                self_params =
+                  if self_type.name.class?
+                    @env.normalized_module_entry(self_type.name)&.type_params
+                  else
+                    @env.interface_decls[self_type.name]&.decl&.type_params
+                  end
+
+                if self_params
+                  InvalidTypeApplicationError.check!(type_name: self_type.name, params: self_params, args: self_type.args, location: self_type.location)
                 end
               end
             end
           end
 
-          d = decl.primary.decl
+          d = entry.primary.decl
 
           @validator.validate_type_params(
             d.type_params,
@@ -139,14 +156,22 @@ EOU
           )
 
           d.type_params.each do |param|
-            if ub = param.upper_bound
+            if ub = param.upper_bound_type
               void_type_context_validator(ub)
               no_self_type_validator(ub)
               no_classish_type_validator(ub)
+              @validator.validate_type(ub, context: nil)
+            end
+
+            if dt = param.default_type
+              void_type_context_validator(dt, true)
+              no_self_type_validator(dt)
+              no_classish_type_validator(dt)
+              @validator.validate_type(dt, context: nil)
             end
           end
 
-          decl.decls.each do |d|
+          entry.decls.each do |d|
             d.decl.each_member do |member|
               case member
               when AST::Members::MethodDefinition
@@ -163,6 +188,15 @@ EOU
                     void_type_context_validator(arg, true)
                   end
                 end
+                params =
+                  if member.name.class?
+                    module_decl = @env.normalized_module_entry(member.name) or raise
+                    module_decl.type_params
+                  else
+                    interface_decl = @env.interface_decls.fetch(member.name)
+                    interface_decl.decl.type_params
+                  end
+                InvalidTypeApplicationError.check!(type_name: member.name, params: params, args: member.args, location: member.location)
               when AST::Members::Var
                 void_type_context_validator(member.type)
                 if member.is_a?(AST::Members::ClassVariable)
@@ -198,6 +232,22 @@ EOU
             location: decl.decl.location&.aref(:type_params)
           )
 
+          decl.decl.type_params.each do |param|
+            if ub = param.upper_bound_type
+              void_type_context_validator(ub)
+              no_self_type_validator(ub)
+              no_classish_type_validator(ub)
+              @validator.validate_type(ub, context: nil)
+            end
+
+            if dt = param.default_type
+              void_type_context_validator(dt, true)
+              no_self_type_validator(dt)
+              no_classish_type_validator(dt)
+              @validator.validate_type(dt, context: nil)
+            end
+          end
+
           decl.decl.members.each do |member|
             case member
             when AST::Members::MethodDefinition
@@ -244,7 +294,31 @@ EOU
           @builder.expand_alias1(name).tap do |type|
             @validator.validate_type type, context: nil
           end
+
           @validator.validate_type_alias(entry: decl)
+
+          @validator.validate_type_params(
+            decl.decl.type_params,
+            type_name: name,
+            location: decl.decl.location&.aref(:type_params)
+          )
+
+          decl.decl.type_params.each do |param|
+            if ub = param.upper_bound_type
+              void_type_context_validator(ub)
+              no_self_type_validator(ub)
+              no_classish_type_validator(ub)
+              @validator.validate_type(ub, context: nil)
+            end
+
+            if dt = param.default_type
+              void_type_context_validator(dt, true)
+              no_self_type_validator(dt)
+              no_classish_type_validator(dt)
+              @validator.validate_type(dt, context: nil)
+            end
+          end
+
           no_self_type_validator(decl.decl.type)
           no_classish_type_validator(decl.decl.type)
           void_type_context_validator(decl.decl.type)

data/lib/rbs/cli.rb

@@ -109,7 +109,7 @@ module RBS
     end
 
     def has_parser?
-      defined?(RubyVM::AbstractSyntaxTree)
+      defined?(RubyVM::AbstractSyntaxTree) ? true : false
     end
 
     def run(args)
@@ -909,7 +909,7 @@ Options:
       syntax_error = false
       bufs = args.flat_map do |path|
         path = Pathname(path)
-        FileFinder.each_file(path, skip_hidden: false, immediate: true).map do |file_path|
+        FileFinder.each_file(path, skip_hidden: false).map do |file_path|
           Buffer.new(content: file_path.read, name: file_path)
         end
       end
@@ -1193,7 +1193,7 @@ EOB
       end
 
       minuend_paths.each do |minuend_path|
-        FileFinder.each_file(Pathname(minuend_path), immediate: true, skip_hidden: true) do |rbs_path|
+        FileFinder.each_file(Pathname(minuend_path), skip_hidden: true) do |rbs_path|
           buf = Buffer.new(name: rbs_path, content: rbs_path.read)
           _, dirs, decls = Parser.parse_signature(buf)
           subtracted = Subtractor.new(decls, subtrahend).call

data/lib/rbs/definition.rb

@@ -238,10 +238,11 @@ module RBS
       end
 
       def apply(args, location:)
+        # Assume default types of type parameters are already added to `args`
         InvalidTypeApplicationError.check!(
           type_name: type_name,
           args: args,
-          params: params,
+          params: params.map { AST::TypeParam.new(name: _1, variance: :invariant, upper_bound: nil, location: nil, default_type: nil) },
           location: location
         )
 

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -213,12 +213,15 @@ module RBS
             end
 
             super_name = env.normalize_module_name(super_name)
-
+            
             NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
             if super_class
               InheritModuleError.check!(super_class, env: env)
             end
 
+            super_entry = env.normalized_class_entry(super_name) or raise
+            super_args = AST::TypeParam.normalize_args(super_entry.type_params, super_args)
+
             ancestors = OneAncestors.class_instance(
               type_name: type_name,
               params: params,
@@ -243,9 +246,17 @@ module RBS
 
               module_name = module_self.name
               if module_name.class?
-                module_name = env.normalize_module_name(module_name)
+                module_entry = env.normalized_module_class_entry(module_name) or raise
+                module_name = module_entry.name
+                self_args = AST::TypeParam.normalize_args(module_entry.type_params, module_self.args)
+              end
+              if module_name.interface?
+                interface_entry = env.interface_decls.fetch(module_name)
+                self_args = AST::TypeParam.normalize_args(interface_entry.decl.type_params, module_self.args)
               end
-              self_types.push Definition::Ancestor::Instance.new(name: module_name, args: module_self.args, source: module_self)
+              self_args or raise
+
+              self_types.push Definition::Ancestor::Instance.new(name: module_name, args: self_args, source: module_self)
             end
           end
         end
@@ -346,11 +357,17 @@ module RBS
               MixinClassError.check!(type_name: type_name, env: env, member: member)
               NoMixinFoundError.check!(member.name, env: env, member: member)
 
+              module_decl = env.normalized_module_entry(module_name) or raise
+              module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+
               module_name = env.normalize_module_name(module_name)
               included_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
             when member.name.interface? && included_interfaces
               NoMixinFoundError.check!(member.name, env: env, member: member)
 
+              interface_decl = env.interface_decls.fetch(module_name)
+              module_args = AST::TypeParam.normalize_args(interface_decl.decl.type_params, module_args)
+
               included_interfaces << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
             end
 
@@ -359,8 +376,11 @@ module RBS
               MixinClassError.check!(type_name: type_name, env: env, member: member)
               NoMixinFoundError.check!(member.name, env: env, member: member)
 
-              module_name = env.normalize_module_name(member.name)
+              module_decl = env.normalized_module_entry(member.name) or raise
+              module_name = module_decl.name
+
               module_args = member.args.map {|type| align_params ? type.sub(align_params) : type }
+              module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
 
               prepended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
             end
@@ -374,11 +394,17 @@ module RBS
               MixinClassError.check!(type_name: type_name, env: env, member: member)
               NoMixinFoundError.check!(member.name, env: env, member: member)
 
+              module_decl = env.normalized_module_entry(module_name) or raise
+              module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+
               module_name = env.normalize_module_name(module_name)
               extended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
             when member.name.interface? && extended_interfaces
               NoMixinFoundError.check!(member.name, env: env, member: member)
 
+              interface_decl = env.interface_decls.fetch(module_name)
+              module_args = AST::TypeParam.normalize_args(interface_decl.decl.type_params, module_args)
+
               extended_interfaces << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
             end
           end

data/lib/rbs/definition_builder.rb

@@ -37,7 +37,7 @@ module RBS
       interface_methods = interface_methods(included_interfaces)
       methods = method_builder.build_interface(type_name)
 
-      import_methods(definition, type_name, methods, interface_methods, subst)
+      import_methods(definition, type_name, methods, interface_methods, subst, nil)
     end
 
     def build_interface(type_name)
@@ -86,6 +86,19 @@ module RBS
       one_ancestors = ancestor_builder.one_instance_ancestors(type_name)
       methods = method_builder.build_instance(type_name)
 
+      self_type_methods = one_ancestors.each_self_type.with_object({}) do |self_type, hash| #$ Hash[Symbol, Definition::Method]
+        self_type.args.each do |arg|
+          validate_type_presence(arg)
+        end
+
+        self_type_defn = self_type.name.interface? ? build_interface(self_type.name) : build_instance(self_type.name)
+
+        s = subst + tapp_subst(self_type.name, self_type.args)
+        self_type_defn.methods.each do |method_name, method_def|
+          hash[method_name] = method_def.sub(s)
+        end
+      end
+
       one_ancestors.each_included_module do |mod|
         mod.args.each do |arg|
           validate_type_presence(arg)
@@ -100,7 +113,7 @@ module RBS
         [interface, *other_interfaces]
       end
       interface_methods = interface_methods(all_interfaces)
-      import_methods(definition, type_name, methods, interface_methods, subst)
+      import_methods(definition, type_name, methods, interface_methods, subst, self_type_methods)
 
       one_ancestors.each_prepended_module do |mod|
         mod.args.each do |arg|
@@ -254,7 +267,7 @@ module RBS
             [interface, *other_interfaces]
           end
           interface_methods = interface_methods(all_interfaces)
-          import_methods(definition, type_name, methods, interface_methods, Substitution.new)
+          import_methods(definition, type_name, methods, interface_methods, Substitution.new, nil)
 
           entry.decls.each do |d|
             d.decl.members.each do |member|
@@ -529,7 +542,7 @@ module RBS
       )
     end
 
-    def import_methods(definition, module_name, module_methods, interfaces_methods, subst)
+    def import_methods(definition, module_name, module_methods, interfaces_methods, subst, self_type_methods)
       new_methods = {} #: Hash[Symbol, Definition::Method]
       interface_method_duplicates = Set[] #: Set[Symbol]
 
@@ -567,6 +580,7 @@ module RBS
             definition,
             method,
             subst_,
+            nil,
             defined_in: interface.name,
             implemented_in: module_name
           )
@@ -579,6 +593,7 @@ module RBS
           definition,
           method,
           subst,
+          self_type_methods,
           defined_in: module_name,
           implemented_in: module_name.interface? ? nil : module_name
         )
@@ -587,12 +602,12 @@ module RBS
       definition.methods.merge!(new_methods)
     end
 
-    def define_method(methods, definition, method, subst, defined_in:, implemented_in: defined_in)
+    def define_method(methods, definition, method, subst, self_type_methods, defined_in:, implemented_in: defined_in)
       existing_method = methods[method.name] || definition.methods[method.name]
 
       case original = method.original
       when AST::Members::Alias
-        original_method = methods[original.old_name] || definition.methods[original.old_name]
+        original_method = methods[original.old_name] || definition.methods[original.old_name] || self_type_methods&.fetch(original.old_name, nil)
 
         unless original_method
           raise UnknownMethodAliasError.new(

data/lib/rbs/environment_loader.rb

@@ -152,7 +152,7 @@ module RBS
       each_dir do |source, dir|
         skip_hidden = !source.is_a?(Pathname)
 
-        FileFinder.each_file(dir, skip_hidden: skip_hidden, immediate: true) do |path|
+        FileFinder.each_file(dir, skip_hidden: skip_hidden) do |path|
           next if files.include?(path)
 
           files << path