rbs 2.8.4 → 3.8.1

data/lib/rbs/ast/directives.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Directives
+      class Base
+      end
+
+      class Use < Base
+        class SingleClause
+          attr_reader :type_name, :new_name, :location
+
+          def initialize(type_name:, new_name:, location:)
+            @type_name = type_name
+            @new_name = new_name
+            @location = location
+          end
+        end
+
+        class WildcardClause
+          attr_reader :namespace, :location
+
+          def initialize(namespace:, location:)
+            @location = location
+            @namespace = namespace
+          end
+        end
+
+        attr_reader :clauses, :location
+
+        def initialize(clauses:, location:)
+          @clauses = clauses
+          @location = location
+        end
+      end
+
+    end
+  end
+end

data/lib/rbs/ast/members.rb

@@ -7,23 +7,57 @@ module RBS
       end
 
       class MethodDefinition < Base
+        class Overload
+          attr_reader :method_type, :annotations
+
+          def initialize(method_type:, annotations:)
+            @method_type = method_type
+            @annotations = annotations
+          end
+
+          def ==(other)
+            other.is_a?(Overload) && other.method_type == method_type && other.annotations == annotations
+          end
+
+          def hash
+            method_type.hash ^ annotations.hash
+          end
+
+          alias eql? ==
+
+          def update(annotations: self.annotations, method_type: self.method_type)
+            Overload.new(annotations: annotations, method_type: method_type)
+          end
+
+          def sub(subst)
+            update(method_type: self.method_type.sub(subst))
+          end
+
+          def to_json(state = _ = nil)
+            {
+              annotations: annotations,
+              method_type: method_type
+            }.to_json(state)
+          end
+        end
+
         attr_reader :name
         attr_reader :kind
-        attr_reader :types
+        attr_reader :overloads
         attr_reader :annotations
         attr_reader :location
         attr_reader :comment
-        attr_reader :overload
+        attr_reader :overloading
         attr_reader :visibility
 
-        def initialize(name:, kind:, types:, annotations:, location:, comment:, overload:, visibility: nil)
+        def initialize(name:, kind:, overloads:, annotations:, location:, comment:, overloading:, visibility:)
           @name = name
           @kind = kind
-          @types = types
+          @overloads = overloads
           @annotations = annotations
           @location = location
           @comment = comment
-          @overload = overload ? true : false
+          @overloading = overloading
           @visibility = visibility
         end
 
@@ -31,15 +65,15 @@ module RBS
           other.is_a?(MethodDefinition) &&
             other.name == name &&
             other.kind == kind &&
-            other.types == types &&
-            other.overload == overload &&
+            other.overloads == overloads &&
+            other.overloading? == overloading? &&
             other.visibility == visibility
         end
 
         alias eql? ==
 
         def hash
-          name.hash ^ kind.hash ^ types.hash ^ overload.hash
+          name.hash ^ kind.hash ^ overloads.hash ^ overloading?.hash ^ visibility.hash
         end
 
         def instance?
@@ -50,19 +84,19 @@ module RBS
           kind == :singleton || kind == :singleton_instance
         end
 
-        def overload?
-          overload
+        def overloading?
+          overloading
         end
 
-        def update(name: self.name, kind: self.kind, types: self.types, annotations: self.annotations, location: self.location, comment: self.comment, overload: self.overload, visibility: self.visibility)
+        def update(name: self.name, kind: self.kind, overloads: self.overloads, annotations: self.annotations, location: self.location, comment: self.comment, overloading: self.overloading?, visibility: self.visibility)
           self.class.new(
             name: name,
             kind: kind,
-            types: types,
+            overloads: overloads,
             annotations: annotations,
             location: location,
             comment: comment,
-            overload: overload,
+            overloading: overloading,
             visibility: visibility
           )
         end
@@ -72,11 +106,11 @@ module RBS
             member: :method_definition,
             name: name,
             kind: kind,
-            types: types,
+            overloads: overloads,
             annotations: annotations,
             location: location,
             comment: comment,
-            overload: overload,
+            overloading: overloading?,
             visibility: visibility
           }.to_json(state)
         end

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,84 @@ 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)
+        if params.empty?
+          return nil
+        end
+
+        optional_params, required_params = params.partition {|param| param.default_type }
+
+        param_subst = Substitution.new()
+        app_subst = Substitution.new()
+
+        required_params.zip(args.take(required_params.size)).each do |param, arg|
+          arg ||= Types::Bases::Any.new(location: nil)
+          param_subst.add(from: param.name, to: arg)
+          app_subst.add(from: param.name, to: arg)
+        end
+
+        optional_params.each do |param|
+          param_subst.add(from: param.name, to: Types::Bases::Any.new(location: nil))
+        end
+
+        optional_params.zip(args.drop(required_params.size)).each do |param, arg|
+          if arg
+            app_subst.add(from: param.name, to: arg)
+          else
+            param.default_type or raise
+            app_subst.add(from: param.name, to: param.default_type.sub(param_subst))
+          end
+        end
+
+        app_subst
+      end
+
+      def self.normalize_args(params, args)
+        app = application(params, args) or return []
+
+        min_count = params.count { _1.default_type.nil? }
+        unless min_count <= args.size && args.size <= params.size
+          return args
+        end
+
+        params.zip(args).filter_map do |param, arg|
+          if arg
+            arg
+          else
+            if param.default_type
+              param.default_type.sub(app)
+            else
+              Types::Bases::Any.new(location: nil)
+            end
+          end
+        end
+      end
+
+      def self.validate(type_params)
+        optionals = type_params.filter {|param| param.default_type }
+
+        optional_param_names = optionals.map(&:name).sort
+
+        optionals.filter! do |param|
+          default_type = param.default_type or raise
+          optional_param_names.any? { default_type.free_variables.include?(_1) }
+        end
+
+        unless optionals.empty?
+          optionals
+        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/colored_io.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RBS
+  class CLI
+    class ColoredIO
+      attr_reader :stdout
+
+      def initialize(stdout:)
+        @stdout = stdout
+      end
+
+      def puts_red(string)
+        if can_display_colors?
+          puts "\e[31m#{string}\e[m"
+        else
+          puts string
+        end
+      end
+
+      def puts_green(string)
+        if can_display_colors?
+          puts "\e[32m#{string}\e[m"
+        else
+          puts string
+        end
+      end
+
+      def puts(...)
+        stdout.puts(...)
+      end
+
+      private
+
+      # https://github.com/rubygems/rubygems/blob/ed65279100234a17d65d71fe26de5083984ac5b8/bundler/lib/bundler/vendor/thor/lib/thor/shell/color.rb#L99-L109
+      def can_display_colors?
+        are_colors_supported? && !are_colors_disabled?
+      end
+
+      def are_colors_supported?
+        stdout.tty? && ENV["TERM"] != "dumb"
+      end
+
+      def are_colors_disabled?
+        !ENV['NO_COLOR'].nil? && !ENV.fetch('NO_COLOR', '').empty?
+      end
+    end
+  end
+end

data/lib/rbs/cli/diff.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RBS
+  class CLI
+    class Diff
+      def initialize(argv:, library_options:, stdout: $stdout, stderr: $stderr)
+        @format = nil
+        @stdout = stdout
+        @stderr = stderr
+
+        # @type var type_name: String?
+        type_name = nil
+        library_options = library_options
+        before_path = [] #: Array[String]
+        after_path = [] #: Array[String]
+        detail = false
+
+        opt = OptionParser.new do |o|
+          o.banner = <<~HELP
+            [Experimental] This command is experimental. API and output compatibility is not guaranteed.
+
+            Usage:
+              rbs diff --format markdown --type-name Foo --before before_sig --after after_sig
+
+            Print diff for rbs environment dir
+
+            Examples:
+
+              # Diff dir1 and dir2 for Foo
+              $ rbs diff --format markdown --type-name Foo --before dir1 --after dir2
+
+              # Confirmation of methods related to Time class added by including stdlib/time
+              $ rbs diff --format diff --type-name Time --after stdlib/time
+          HELP
+          o.on("--format NAME")    { |arg| @format = arg }
+          o.on("--type-name NAME") { |arg| type_name = arg }
+          o.on("--before DIR")     { |arg| before_path << arg }
+          o.on("--after DIR")      { |arg| after_path << arg }
+          o.on("--[no-]detail")    { |arg| detail = arg }
+        end
+        opt.parse!(argv)
+
+        unless @format && type_name && ["markdown", "diff"].include?(@format)
+          @stderr.puts opt.banner
+          exit 1
+        end
+
+        @diff = RBS::Diff.new(
+          type_name: TypeName.parse(type_name).absolute!,
+          library_options: library_options,
+          after_path: after_path,
+          before_path: before_path,
+          detail: detail,
+        )
+      end
+
+      def run
+        public_send("run_#{@format}")
+      end
+
+      def run_diff
+        first = true
+        io = RBS::CLI::ColoredIO.new(stdout: @stdout)
+        @diff.each_diff do |before, after|
+          io.puts if !first
+          io.puts_red   "- #{before}"
+          io.puts_green "+ #{after}"
+          first = false
+        end
+      end
+
+      def run_markdown
+        @stdout.puts "| before | after |"
+        @stdout.puts "| --- | --- |"
+        @diff.each_diff do |before, after|
+          before.gsub!("|", "\\|")
+          after.gsub!("|", "\\|")
+          @stdout.puts "| `#{before}` | `#{after}` |"
+        end
+      end
+    end
+  end
+end