rbs 3.10.4 → 4.0.0

data/lib/rbs/ast/ruby/annotations.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Annotations
+        class Base
+          attr_reader :location, :prefix_location
+
+          def initialize(location, prefix_location)
+            @location = location
+            @prefix_location = prefix_location
+          end
+
+          def buffer
+            location.buffer
+          end
+        end
+
+        class NodeTypeAssertion < Base
+          attr_reader :type
+
+          def initialize(location:, prefix_location:, type:)
+            super(location, prefix_location)
+            @type = type
+          end
+
+          def map_type_name
+            self.class.new(
+              location:, prefix_location:,
+              type: type.map_type_name { yield _1 }
+            ) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/node_type_assertion",
+              type.to_s
+            ]
+          end
+        end
+
+        class AliasAnnotation < Base
+          attr_reader :keyword_location, :type_name_location, :type_name
+
+          def initialize(location:, prefix_location:, keyword_location:, type_name:, type_name_location:)
+            super(location, prefix_location)
+            @keyword_location = keyword_location
+            @type_name = type_name
+            @type_name_location = type_name_location
+          end
+
+          def map_type_name
+            self.class.new(
+              location:,
+              prefix_location:,
+              keyword_location:,
+              type_name: type_name ? yield(type_name) : nil,
+              type_name_location:
+            ) #: self
+          end
+        end
+
+        class ClassAliasAnnotation < AliasAnnotation
+          def type_fingerprint
+            [
+              "annots/class-alias",
+              type_name&.to_s
+            ]
+          end
+        end
+
+        class ModuleAliasAnnotation < AliasAnnotation
+          def type_fingerprint
+            [
+              "annots/module-alias",
+              type_name&.to_s
+            ]
+          end
+        end
+
+        class ColonMethodTypeAnnotation < Base
+          attr_reader :annotations, :method_type
+
+          def initialize(location:, prefix_location:, annotations:, method_type:)
+            super(location, prefix_location)
+            @annotations = annotations
+            @method_type = method_type
+          end
+
+          def map_type_name
+            self.class.new(
+              location:,
+              prefix_location:,
+              annotations: annotations,
+              method_type: method_type.map_type {|type| type.map_type_name { yield _1 }}
+            ) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/colon_method_type",
+              annotations.map(&:to_s),
+              method_type.to_s
+            ]
+          end
+        end
+
+        class MethodTypesAnnotation < Base
+          Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader :overloads, :vertical_bar_locations, :dot3_location
+
+          def initialize(location:, prefix_location:, overloads:, vertical_bar_locations:, dot3_location:)
+            super(location, prefix_location)
+            @overloads = overloads
+            @vertical_bar_locations = vertical_bar_locations
+            @dot3_location = dot3_location
+          end
+
+          def map_type_name(&block)
+            ovs = overloads.map do |overload|
+              Overload.new(
+                method_type: overload.method_type.map_type {|type| type.map_type_name { yield _1 } },
+                annotations: overload.annotations
+              )
+            end
+
+            self.class.new(location:, prefix_location:, overloads: ovs, vertical_bar_locations:, dot3_location:) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/method_types",
+              overloads.map { |o| [o.annotations.map(&:to_s), o.method_type.to_s] },
+              overloading: dot3_location ? true : false
+            ]
+          end
+        end
+
+        class SkipAnnotation < Base
+          attr_reader :skip_location, :comment_location
+
+          def initialize(location:, prefix_location:, skip_location:, comment_location:)
+            super(location, prefix_location)
+            @skip_location = skip_location
+            @comment_location = comment_location
+          end
+
+          def type_fingerprint
+            "annots/skip"
+          end
+        end
+
+        class ReturnTypeAnnotation < Base
+          attr_reader :return_location
+
+          attr_reader :colon_location
+
+          attr_reader :return_type
+
+          attr_reader :comment_location
+
+          def initialize(location:, prefix_location:, return_location:, colon_location:, return_type:, comment_location:)
+            super(location, prefix_location)
+            @return_location = return_location
+            @colon_location = colon_location
+            @return_type = return_type
+            @comment_location = comment_location
+          end
+
+          def map_type_name(&block)
+            self.class.new(
+              location:,
+              prefix_location:,
+              return_location: return_location,
+              colon_location: colon_location,
+              return_type: return_type.map_type_name { yield _1 },
+              comment_location: comment_location
+            ) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/return_type",
+              return_type.to_s,
+              comment_location&.source
+            ]
+          end
+        end
+
+        class TypeApplicationAnnotation < Base
+          attr_reader :type_args, :close_bracket_location, :comma_locations
+
+          def initialize(location:, prefix_location:, type_args:, close_bracket_location:, comma_locations:)
+            super(location, prefix_location)
+            @type_args = type_args
+            @close_bracket_location = close_bracket_location
+            @comma_locations = comma_locations
+          end
+
+          def map_type_name(&block)
+            mapped_type_args = type_args.map { |type| type.map_type_name { yield _1 } }
+
+            self.class.new(
+              location:,
+              prefix_location:,
+              type_args: mapped_type_args,
+              close_bracket_location:,
+              comma_locations:
+            ) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/type_application",
+              type_args.map(&:to_s)
+            ]
+          end
+        end
+
+        class InstanceVariableAnnotation < Base
+          attr_reader :ivar_name, :ivar_name_location, :colon_location, :type, :comment_location
+
+          def initialize(location:, prefix_location:, ivar_name:, ivar_name_location:, colon_location:, type:, comment_location:)
+            super(location, prefix_location)
+            @ivar_name = ivar_name
+            @ivar_name_location = ivar_name_location
+            @colon_location = colon_location
+            @type = type
+            @comment_location = comment_location
+          end
+
+          def map_type_name(&block)
+            self.class.new(
+              location:,
+              prefix_location:,
+              ivar_name:,
+              ivar_name_location:,
+              colon_location:,
+              type: type.map_type_name { yield _1 },
+              comment_location:
+            ) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/instance_variable",
+              ivar_name.to_s,
+              type.to_s,
+              comment_location&.source
+            ]
+          end
+        end
+
+        class ParamTypeAnnotation < Base
+          attr_reader :name_location, :colon_location, :param_type, :comment_location
+
+          def initialize(location:, prefix_location:, name_location:, colon_location:, param_type:, comment_location:)
+            super(location, prefix_location)
+            @name_location = name_location
+            @colon_location = colon_location
+            @param_type = param_type
+            @comment_location = comment_location
+          end
+
+          def map_type_name(&block)
+            self.class.new(
+              location:,
+              prefix_location:,
+              name_location: name_location,
+              colon_location: colon_location,
+              param_type: param_type.map_type_name { yield _1 },
+              comment_location: comment_location
+            ) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/param_type",
+              name_location.source,
+              param_type.to_s,
+              comment_location&.source
+            ]
+          end
+        end
+
+        class SplatParamTypeAnnotation < Base
+          attr_reader :star_location, :name_location, :colon_location, :param_type, :comment_location
+
+          def initialize(location:, prefix_location:, star_location:, name_location:, colon_location:, param_type:, comment_location:)
+            super(location, prefix_location)
+            @star_location = star_location
+            @name_location = name_location
+            @colon_location = colon_location
+            @param_type = param_type
+            @comment_location = comment_location
+          end
+
+          def map_type_name(&block)
+            self.class.new(
+              location:,
+              prefix_location:,
+              star_location: star_location,
+              name_location: name_location,
+              colon_location: colon_location,
+              param_type: param_type.map_type_name { yield _1 },
+              comment_location: comment_location
+            ) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/splat_param_type",
+              name_location&.source,
+              param_type.to_s,
+              comment_location&.source
+            ]
+          end
+        end
+
+        class DoubleSplatParamTypeAnnotation < Base
+          attr_reader :star2_location, :name_location, :colon_location, :param_type, :comment_location
+
+          def initialize(location:, prefix_location:, star2_location:, name_location:, colon_location:, param_type:, comment_location:)
+            super(location, prefix_location)
+            @star2_location = star2_location
+            @name_location = name_location
+            @colon_location = colon_location
+            @param_type = param_type
+            @comment_location = comment_location
+          end
+
+          def map_type_name(&block)
+            self.class.new(
+              location:,
+              prefix_location:,
+              star2_location: star2_location,
+              name_location: name_location,
+              colon_location: colon_location,
+              param_type: param_type.map_type_name { yield _1 },
+              comment_location: comment_location
+            ) #: self
+          end
+
+          def type_fingerprint
+            [
+              "annots/double_splat_param_type",
+              name_location&.source,
+              param_type.to_s,
+              comment_location&.source
+            ]
+          end
+        end
+
+        class BlockParamTypeAnnotation < Base
+          attr_reader :ampersand_location, :name_location, :colon_location, :question_location, :type_location, :type, :comment_location
+
+          def initialize(location:, prefix_location:, ampersand_location:, name_location:, colon_location:, question_location:, type_location:, type:, comment_location:)
+            super(location, prefix_location)
+            @ampersand_location = ampersand_location
+            @name_location = name_location
+            @colon_location = colon_location
+            @question_location = question_location
+            @type_location = type_location
+            @type = type
+            @comment_location = comment_location
+          end
+
+          def map_type_name(&block)
+            self.class.new(
+              location:,
+              prefix_location:,
+              ampersand_location: ampersand_location,
+              name_location: name_location,
+              colon_location: colon_location,
+              question_location: question_location,
+              type_location: type_location,
+              type: type.map_type_name { yield _1 },
+              comment_location: comment_location
+            ) #: self
+          end
+
+          def name
+            name_location&.source&.to_sym
+          end
+
+          def optional?
+            question_location ? true : false
+          end
+
+          def required?
+            !optional?
+          end
+
+          def type_fingerprint
+            [
+              "annots/block_param_type",
+              name_location&.source,
+              type.to_s,
+              optional? ? "optional" : "required",
+              comment_location&.source
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/ast/ruby/comment_block.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      class CommentBlock
+        attr_reader :name, :offsets, :comment_buffer
+
+        def initialize(source_buffer, comments)
+          @name = source_buffer.name
+
+          @offsets = []
+
+          # Assume the comment starts with a prefix whitespace
+          prefix_str = "# "
+
+          ranges = [] #: Array[Range[Integer]]
+
+          comments.each do |comment|
+            tuple = [comment, 2] #: [Prism::Comment, Integer]
+
+            unless comment.location.slice.start_with?(prefix_str)
+              tuple[1] = 1
+            end
+
+            offsets << tuple
+
+            start_char = comment.location.start_character_offset + tuple[1]
+            end_char = comment.location.end_character_offset
+            ranges << (start_char ... end_char)
+          end
+
+          @comment_buffer = source_buffer.sub_buffer(lines: ranges)
+        end
+
+        def leading?
+          comment = offsets[0][0] or raise
+          comment.location.start_line_slice.index(/\S/) ? false : true
+        end
+
+        def trailing?
+          comment = offsets[0][0] or raise
+          comment.location.start_line_slice.index(/\S/) ? true : false
+        end
+
+        def start_line
+          comments[0].location.start_line
+        end
+
+        def end_line
+          comments[-1].location.end_line
+        end
+
+        def line_starts
+          offsets.map do |comment, prefix_size|
+            comment.location.start_character_offset + prefix_size
+          end
+        end
+
+        def self.build(buffer, comments)
+          blocks = [] #: Array[CommentBlock]
+
+          comments = comments.filter {|comment| comment.is_a?(Prism::InlineComment) }
+
+          until comments.empty?
+            block_comments = [] #: Array[Prism::Comment]
+
+            until comments.empty?
+              comment = comments.first or raise
+              last_comment = block_comments.last
+
+              if last_comment
+                if last_comment.location.end_line + 1 == comment.location.start_line
+                  if last_comment.location.start_column == comment.location.start_column
+                    unless comment.location.start_line_slice.index(/\S/)
+                      block_comments << comments.shift
+                      next
+                    end
+                  end
+                end
+
+                break
+              else
+                block_comments << comments.shift
+              end
+            end
+
+            unless block_comments.empty?
+              blocks << CommentBlock.new(buffer, block_comments.dup)
+            end
+          end
+
+          blocks
+        end
+
+        AnnotationSyntaxError = _ = Struct.new(:location, :error)
+
+        def each_paragraph(variables, &block)
+          if block
+            if leading_annotation?(0)
+              yield_annotation(0, 0, 0, variables, &block)
+            else
+              yield_paragraph(0, 0, variables, &block)
+            end
+          else
+            enum_for :each_paragraph, variables
+          end
+        end
+
+        def yield_paragraph(start_line, current_line, variables, &block)
+          # We already know at start_line..current_line are paragraph.
+
+          while true
+            next_line = current_line + 1
+
+            if next_line >= comment_buffer.line_count
+              yield line_location(start_line, current_line)
+              return
+            end
+
+            if leading_annotation?(next_line)
+              yield line_location(start_line, current_line)
+              return yield_annotation(next_line, next_line, next_line, variables, &block)
+            else
+              current_line = next_line
+            end
+          end
+        end
+
+        def yield_annotation(start_line, end_line, current_line, variables, &block)
+          # We already know at start_line..end_line are annotation.
+          while true
+            next_line = current_line + 1
+
+            if next_line >= comment_buffer.line_count
+              annotation = parse_annotation_lines(start_line, end_line, variables)
+              yield annotation
+
+              if end_line > current_line
+                yield_paragraph(end_line + 1, end_line + 1, variables, &block)
+              end
+
+              return
+            end
+
+            line_text = text(next_line)
+            if leading_spaces = line_text.index(/\S/)
+              if leading_spaces == 0
+                # End of annotation
+                yield parse_annotation_lines(start_line, end_line, variables)
+
+                if leading_annotation?(end_line + 1)
+                  yield_annotation(end_line + 1, end_line + 1, end_line + 1, variables, &block)
+                else
+                  yield_paragraph(end_line + 1, end_line + 1, variables, &block)
+                end
+
+                return
+              else
+                current_line = next_line
+                end_line = next_line
+              end
+            else
+              current_line = next_line
+            end
+          end
+        end
+
+        def text(comment_index)
+          range = comment_buffer.ranges[comment_index]
+          comment_buffer.content[range] or raise
+        end
+
+        def line_location(start_line, end_line)
+          start_offset = comment_buffer.ranges[start_line].begin
+          end_offset = comment_buffer.ranges[end_line].end
+          Location.new(comment_buffer, start_offset, end_offset)
+        end
+
+        def location()
+          first_comment = comments[0] or raise
+          last_comment = comments[-1] or raise
+
+          comment_buffer.rbs_location(first_comment.location.join last_comment.location)
+        end
+
+        def parse_annotation_lines(start_line, end_line, variables)
+          start_pos = comment_buffer.ranges[start_line].begin
+          end_pos = comment_buffer.ranges[end_line].end
+          begin
+            Parser.parse_inline_leading_annotation(comment_buffer, start_pos...end_pos, variables: variables)
+          rescue ParsingError => error
+            AnnotationSyntaxError.new(line_location(start_line, end_line), error)
+          end
+        end
+
+        def trailing_annotation(variables)
+          if trailing?
+            comment = comments[0] or raise
+            if comment.location.slice.start_with?(/#[:\[]/)
+              begin
+                Parser.parse_inline_trailing_annotation(comment_buffer, 0...comment_buffer.last_position, variables: variables)
+              rescue ParsingError => error
+                location = line_location(0, offsets.size - 1)
+                AnnotationSyntaxError.new(location, error)
+              end
+            end
+          end
+        end
+
+        def comments
+          offsets.map { _1[0]}
+        end
+
+        def leading_annotation?(index)
+          if index < comment_buffer.line_count
+            text(index).start_with?(/@rbs\b/) and return true
+
+            comment = offsets[index][0]
+            comment.location.slice.start_with?(/\#:/) and return true
+          end
+
+          false
+        end
+
+        def as_comment
+          lines = [] #: Array[String]
+
+          each_paragraph([]) do |paragraph|
+            case paragraph
+            when Location
+              lines << paragraph.local_source
+            end
+          end
+
+          string = lines.join("\n")
+
+          unless string.strip.empty?
+            AST::Comment.new(string: string, location: location)
+          end
+        end
+      end
+    end
+  end
+end