rbs 3.10.4 → 4.0.0

data/lib/rbs/ast/type_param.rb

@@ -3,12 +3,13 @@
 module RBS
   module AST
     class TypeParam
-      attr_reader :name, :variance, :location, :upper_bound_type, :default_type
+      attr_reader :name, :variance, :location, :upper_bound_type, :lower_bound_type, :default_type
 
-      def initialize(name:, variance:, upper_bound:, location:, default_type: nil, unchecked: false)
+      def initialize(name:, variance:, upper_bound:, lower_bound:, location:, default_type: nil, unchecked: false)
         @name = name
         @variance = variance
         @upper_bound_type = upper_bound
+        @lower_bound_type = lower_bound
         @location = location
         @default_type = default_type
         @unchecked = unchecked
@@ -21,6 +22,13 @@ module RBS
         end
       end
 
+      def lower_bound
+        case lower_bound_type
+        when Types::ClassInstance, Types::ClassSingleton, Types::Interface
+          lower_bound_type
+        end
+      end
+
       def unchecked!(value = true)
         @unchecked = value ? true : false
         self
@@ -35,6 +43,7 @@ module RBS
           other.name == name &&
           other.variance == variance &&
           other.upper_bound_type == upper_bound_type &&
+          other.lower_bound_type == lower_bound_type &&
           other.default_type == default_type &&
           other.unchecked? == unchecked?
       end
@@ -42,7 +51,7 @@ module RBS
       alias eql? ==
 
       def hash
-        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound_type.hash ^ unchecked?.hash ^ default_type.hash
+        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound_type.hash ^ lower_bound_type.hash ^ unchecked?.hash ^ default_type.hash
       end
 
       def to_json(state = JSON::State.new)
@@ -52,6 +61,7 @@ module RBS
           unchecked: unchecked?,
           location: location,
           upper_bound: upper_bound_type,
+          lower_bound: lower_bound_type,
           default_type: default_type
         }.to_json(state)
       end
@@ -61,6 +71,10 @@ module RBS
           _upper_bound_type = yield(b)
         end
 
+        if b = lower_bound_type
+          _lower_bound_type = yield(b)
+        end
+
         if dt = default_type
           _default_type = yield(dt)
         end
@@ -69,6 +83,7 @@ module RBS
           name: name,
           variance: variance,
           upper_bound: _upper_bound_type,
+          lower_bound: _lower_bound_type,
           location: location,
           default_type: _default_type
         ).unchecked!(unchecked?)
@@ -108,6 +123,7 @@ module RBS
             name: new_name,
             variance: param.variance,
             upper_bound: param.upper_bound_type&.map_type {|type| type.sub(subst) },
+            lower_bound: param.lower_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?)
@@ -136,6 +152,10 @@ module RBS
           s << " < #{type}"
         end
 
+        if type = lower_bound_type
+          s << " > #{type}"
+        end
+
         if dt = default_type
           s << " = #{dt}"
         end
@@ -176,7 +196,7 @@ module RBS
       end
 
       def self.normalize_args(params, args)
-        app = application(params, args) or return []
+        app = application(params, args) or return args
 
         min_count = params.count { _1.default_type.nil? }
         unless min_count <= args.size && args.size <= params.size

data/lib/rbs/buffer.rb

@@ -4,39 +4,58 @@ module RBS
   class Buffer
     attr_reader :name
     attr_reader :content
+    attr_reader :parent
 
-    def initialize(name:, content:)
-      @name = name
-      @content = content
+    def initialize(name: nil, content:, parent: nil)
+      case
+      when name && content
+        @name = name
+        @content = content
+        @parent = nil
+      when parent && content
+        @name = parent[0].name
+        @content = content
+        @parent = parent
+      end
     end
 
     def lines
-      @lines ||= content.lines
+      ranges.map { self.content[_1] || raise } #$ String
+    end
+
+    def line_count
+      ranges.size
     end
 
     def ranges
-      @ranges ||=
-        begin
-          @ranges = []
+      @ranges ||= begin
+        if content.empty?
+          ranges = [0...0] #: Array[Range[Integer]]
+          lines = [""]
+        else
+          lines = content.lines
+          lines << "" if content.end_with?("\n")
+
+          ranges = [] #: Array[Range[Integer]]
           offset = 0
+
           lines.each do |line|
-            size = line.size
-            range = offset...(offset+size)
-            @ranges << range
-            offset += size
-          end
+            size0 = line.size
+            line = line.chomp
+            range = offset...(offset+line.size)
+            ranges << range
 
-          if !content.end_with?("\n") && content.size > 0
-            @ranges[-1] = @ranges[-1].begin...(@ranges[-1].end+1)
+            offset += size0
           end
-
-          @ranges
         end
+
+        ranges
+      end
     end
 
     def pos_to_loc(pos)
       index = ranges.bsearch_index do |range|
-        pos < range.end ? true : false
+        pos <= range.end ? true : false
       end
 
       if index
@@ -49,7 +68,7 @@ module RBS
     def loc_to_pos(loc)
       line, column = loc
 
-      if range = ranges[line - 1]
+      if range = ranges.fetch(line - 1, nil)
         range.begin + column
       else
         last_position
@@ -57,11 +76,77 @@ module RBS
     end
 
     def last_position
-      content.size
+      if ranges.empty?
+        0
+      else
+        ranges[-1].end
+      end
     end
 
     def inspect
-      "#<RBS::Buffer:#{__id__} @name=#{name}, @content=#{content.bytesize} bytes, @lines=#{lines.size} lines,>"
+      "#<RBS::Buffer:#{__id__} @name=#{name}, @content=#{content.bytesize} bytes, @lines=#{ranges.size} lines,>"
+    end
+
+    def rbs_location(location, loc2=nil)
+      if loc2
+        Location.new(self.top_buffer, location.start_character_offset, loc2.end_character_offset)
+      else
+        Location.new(self.top_buffer, location.start_character_offset, location.end_character_offset)
+      end
+    end
+
+    def sub_buffer(lines:)
+      buf = +""
+      lines.each_with_index do |range, index|
+        start_pos = range.begin
+        end_pos = range.end
+        slice = content[start_pos...end_pos] or raise
+        if slice.include?("\n")
+          raise "Line #{index + 1} cannot contain newline character."
+        end
+        buf << slice
+        buf << "\n"
+      end
+
+      buf.chomp!
+
+      Buffer.new(content: buf, parent: [self, lines])
+    end
+
+    def parent_buffer
+      if parent
+        parent[0]
+      end
+    end
+
+    def parent_position(position)
+      parent or raise "#parent_position is unavailable with buffer without parent"
+      return nil unless position <= last_position
+
+      line, column = pos_to_loc(position)
+      parent_range = parent[1][line - 1]
+      parent_range.begin + column
+    end
+
+    def absolute_position(position)
+      if parent_buffer
+        pos = parent_position(position) or return
+        parent_buffer.absolute_position(pos)
+      else
+        position
+      end
+    end
+
+    def top_buffer
+      if parent_buffer
+        parent_buffer.top_buffer
+      else
+        self
+      end
+    end
+
+    def detach
+      Buffer.new(name: name, content: content)
     end
   end
 end

data/lib/rbs/cli/diff.rb

@@ -3,13 +3,14 @@
 module RBS
   class CLI
     class Diff
-      def initialize(argv:, library_options:, stdout: $stdout, stderr: $stderr)
-        @format = nil
+      def initialize(stdout: $stdout, stderr: $stderr)
         @stdout = stdout
         @stderr = stderr
+      end
 
-        # @type var type_name: String?
-        type_name = nil
+      def run(argv:, library_options:)
+        format = nil #: String?
+        type_name = nil #: String?
         library_options = library_options
         before_path = [] #: Array[String]
         after_path = [] #: Array[String]
@@ -32,7 +33,7 @@ module RBS
               # 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("--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 }
@@ -40,28 +41,28 @@ module RBS
         end
         opt.parse!(argv)
 
-        unless @format && type_name && ["markdown", "diff"].include?(@format)
+        unless format && type_name && ["markdown", "diff"].include?(format)
           @stderr.puts opt.banner
-          exit 1
+          return 1
         end
 
-        @diff = RBS::Diff.new(
+        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}")
+        public_send("run_#{format}", diff)
+
+        0
       end
 
-      def run_diff
+      def run_diff(diff)
         first = true
         io = RBS::CLI::ColoredIO.new(stdout: @stdout)
-        @diff.each_diff do |before, after|
+        diff.each_diff do |before, after|
           io.puts if !first
           io.puts_red   "- #{before}"
           io.puts_green "+ #{after}"
@@ -69,10 +70,10 @@ module RBS
         end
       end
 
-      def run_markdown
+      def run_markdown(diff)
         @stdout.puts "| before | after |"
         @stdout.puts "| --- | --- |"
-        @diff.each_diff do |before, after|
+        diff.each_diff do |before, after|
           before.gsub!("|", "\\|")
           after.gsub!("|", "\\|")
           @stdout.puts "| `#{before}` | `#{after}` |"

data/lib/rbs/cli/validate.rb

@@ -4,36 +4,33 @@ module RBS
   class CLI
     class Validate
       class Errors
-        def initialize(limit:, exit_error:)
+        def initialize(limit:)
           @limit = limit
-          @exit_error = exit_error
           @errors = []
-          @has_syntax_error = false
         end
 
         def add(error)
-          if error.instance_of?(WillSyntaxError)
-            RBS.logger.warn(build_message(error))
-            @has_syntax_error = true
-          else
-            @errors << error
-          end
+          @errors << error
           finish if @limit == 1
         end
 
+        def try(&block)
+          catch(:finish) do |tag|
+            @tag = tag
+            yield
+            finish()
+          end
+        end
+
         def finish
-          if @errors.empty?
-            if @exit_error && @has_syntax_error
-              exit 1
-            else
-              # success
-            end
-          else
+          unless @errors.empty?
             @errors.each do |error|
               RBS.logger.error(build_message(error))
             end
-            exit 1
+            throw @tag, 1
           end
+
+          0
         end
 
         private
@@ -53,7 +50,6 @@ module RBS
         @env = Environment.from_loader(loader).resolve_type_names
         @builder = DefinitionBuilder.new(env: @env)
         @validator = Validator.new(env: @env)
-        exit_error = false
         limit = nil #: Integer?
         OptionParser.new do |opts|
           opts.banner = <<EOU
@@ -70,25 +66,25 @@ EOU
             RBS.print_warning { "`--silent` option is deprecated because it's silent by default. You can use --log-level option of rbs command to display more information." }
           end
           opts.on("--[no-]exit-error-on-syntax-error", "exit(1) if syntax error is detected") {|bool|
-            exit_error = bool
+            RBS.print_warning { "`--exit-error-on-syntax-error` option is deprecated because it's validated during parsing.." }
           }
           opts.on("--fail-fast", "Exit immediately as soon as a validation error is found.") do |arg|
             limit = 1
           end
         end.parse!(args)
 
-        @errors = Errors.new(limit: limit, exit_error: exit_error)
+        @errors = Errors.new(limit: limit)
       end
 
       def run
-        validate_class_module_definition
-        validate_class_module_alias_definition
-        validate_interface
-        validate_constant
-        validate_global
-        validate_type_alias
-
-        @errors.finish
+        @errors.try do
+          validate_class_module_definition
+          validate_class_module_alias_definition
+          validate_interface
+          validate_constant
+          validate_global
+          validate_type_alias
+        end
       end
 
       private
@@ -109,23 +105,17 @@ EOU
 
           case entry
           when Environment::ClassEntry
-            entry.decls.each do |decl|
-              if super_class = decl.decl.super_class
+            entry.each_decl do |decl|
+              if super_class = 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
               end
             end
           when Environment::ModuleEntry
-            entry.decls.each do |decl|
-              decl.decl.self_types.each do |self_type|
+            entry.each_decl do |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
 
@@ -143,7 +133,7 @@ EOU
             end
           end
 
-          d = entry.primary.decl
+          d = entry.primary_decl
 
           @validator.validate_type_params(
             d.type_params,
@@ -153,55 +143,43 @@ EOU
 
           d.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 lb = param.lower_bound_type
+              @validator.validate_type(lb, 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
 
           TypeParamDefaultReferenceError.check!(d.type_params)
 
-          entry.decls.each do |d|
-            d.decl.each_member do |member|
-              case member
-              when AST::Members::MethodDefinition
-                @validator.validate_method_definition(member, type_name: name)
-                member.overloads.each do |ov|
-                  void_type_context_validator(ov.method_type)
-                end
-              when AST::Members::Attribute
-                void_type_context_validator(member.type)
-              when AST::Members::Mixin
-                member.args.each do |arg|
-                  no_self_type_validator(arg)
-                  unless arg.is_a?(Types::Bases::Void)
-                    void_type_context_validator(arg, true)
-                  end
-                end
-                params =
-                  if member.name.class?
-                    module_decl = @env.module_entry(member.name, normalized: true) 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
-                @validator.validate_variable(member)
-                void_type_context_validator(member.type)
-                if member.is_a?(AST::Members::ClassVariable)
-                  no_self_type_validator(member.type)
+          entry.each_decl do |decl|
+            case decl
+            when AST::Declarations::Base
+              decl.each_member do |member|
+                case member
+                when AST::Members::MethodDefinition
+                  @validator.validate_method_definition(member, type_name: name)
+                when AST::Members::Mixin
+                  params =
+                    if member.name.class?
+                      module_decl = @env.module_entry(member.name, normalized: true) 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
+                  @validator.validate_variable(member)
                 end
               end
+            else
+              raise "Unknown declaration: #{decl.class}"
             end
           end
         rescue BaseError => error
@@ -233,16 +211,14 @@ EOU
 
           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 lb = param.lower_bound_type
+              @validator.validate_type(lb, 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
@@ -253,10 +229,6 @@ EOU
             case member
             when AST::Members::MethodDefinition
               @validator.validate_method_definition(member, type_name: name)
-              member.overloads.each do |ov|
-                void_type_context_validator(ov.method_type)
-                no_classish_type_validator(ov.method_type)
-              end
             end
           end
         rescue BaseError => error
@@ -269,9 +241,6 @@ EOU
           RBS.logger.info "Validating constant: `#{name}`..."
           @validator.validate_type const.decl.type, context: const.context
           @builder.ensure_namespace!(name.namespace, location: const.decl.location)
-          no_self_type_validator(const.decl.type)
-          no_classish_type_validator(const.decl.type)
-          void_type_context_validator(const.decl.type)
         rescue BaseError => error
           @errors.add(error)
         end
@@ -281,9 +250,6 @@ EOU
         @env.global_decls.each do |name, global|
           RBS.logger.info "Validating global: `#{name}`..."
           @validator.validate_type global.decl.type, context: nil
-          no_self_type_validator(global.decl.type)
-          no_classish_type_validator(global.decl.type)
-          void_type_context_validator(global.decl.type)
         rescue BaseError => error
           @errors.add(error)
         end
@@ -306,52 +272,23 @@ EOU
 
           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 lb = param.lower_bound_type
+              @validator.validate_type(lb, 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
 
           TypeParamDefaultReferenceError.check!(decl.decl.type_params)
-
-          no_self_type_validator(decl.decl.type)
-          no_classish_type_validator(decl.decl.type)
-          void_type_context_validator(decl.decl.type)
         rescue BaseError => error
           @errors.add(error)
         end
       end
-
-      private
-
-      def no_self_type_validator(type)
-        if type.has_self_type?
-          @errors.add WillSyntaxError.new("`self` type is not allowed in this context", location: type.location)
-        end
-      end
-
-      def no_classish_type_validator(type)
-        if type.has_classish_type?
-          @errors.add WillSyntaxError.new("`instance` or `class` type is not allowed in this context", location: type.location)
-        end
-      end
-
-      def void_type_context_validator(type, allowed_here = false)
-        if allowed_here
-          return if type.is_a?(Types::Bases::Void)
-        end
-        if type.with_nonreturn_void?
-          @errors.add WillSyntaxError.new("`void` type is only allowed in return type or generics parameter", location: type.location)
-        end
-      end
     end
   end
 end