rbs 3.9.5 → 4.0.0

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

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

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Declarations
+        class Base
+          attr_reader :buffer
+
+          include Helpers::ConstantHelper
+          include Helpers::LocationHelper
+
+          def initialize(buffer)
+            @buffer = buffer
+          end
+        end
+
+        class ClassDecl < Base
+          class SuperClass
+            attr_reader :type_name_location
+
+            attr_reader :operator_location
+
+            attr_reader :type_name
+
+            attr_reader :type_annotation
+
+            def initialize(type_name_location, operator_location, type_name, type_annotation)
+              @type_name_location = type_name_location
+              @operator_location = operator_location
+              @type_name = type_name
+              @type_annotation = type_annotation
+            end
+
+            def type_args
+              if type_annotation
+                type_annotation.type_args
+              else
+                []
+              end
+            end
+
+            def location
+              if type_annotation
+                Location.new(
+                  type_name_location.buffer,
+                  type_name_location.start_pos,
+                  type_annotation.location.end_pos
+                )
+              else
+                type_name_location
+              end
+            end
+
+            alias name type_name
+            alias args type_args
+
+            def type_fingerprint
+              [
+                type_name.to_s,
+                type_annotation&.type_fingerprint
+              ]
+            end
+          end
+
+          attr_reader :class_name
+
+          attr_reader :members
+
+          attr_reader :node
+
+          attr_reader :super_class
+
+          def initialize(buffer, name, node, super_class)
+            super(buffer)
+            @class_name = name
+            @node = node
+            @members = []
+            @super_class = super_class
+          end
+
+          def each_decl(&block)
+            return enum_for(:each_decl) unless block
+
+            @members.each do |member|
+              if member.is_a?(Base)
+                yield member
+              end
+            end
+          end
+
+          def type_params = []
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_location
+            rbs_location(node.constant_path.location)
+          end
+
+          def type_fingerprint
+            result = [] #: Array[untyped]
+
+            result << "decls/class"
+            result << class_name.to_s
+            result << super_class&.type_fingerprint
+            result << members.map { _1.type_fingerprint }
+
+            result
+          end
+        end
+
+        class ModuleDecl < Base
+          attr_reader :module_name
+
+          attr_reader :members
+
+          attr_reader :node
+
+          def initialize(buffer, name, node)
+            super(buffer)
+            @module_name = name
+            @node = node
+            @members = []
+          end
+
+          def each_decl(&block)
+            return enum_for(:each_decl) unless block
+
+            @members.each do |member|
+              if member.is_a?(Base)
+                yield member
+              end
+            end
+          end
+
+          def type_params = []
+
+          def self_types = []
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_location
+            rbs_location(node.constant_path.location)
+          end
+
+          def type_fingerprint
+            result = [] #: Array[untyped]
+
+            result << "decls/module"
+            result << module_name.to_s
+            result << members.map { _1.type_fingerprint}
+
+            result
+          end
+        end
+
+        class ConstantDecl < Base
+          attr_reader :leading_comment
+          attr_reader :constant_name
+          attr_reader :node
+          attr_reader :type_annotation
+
+          def initialize(buffer, constant_name, node, leading_comment, type_annotation)
+            super(buffer)
+            @constant_name = constant_name
+            @node = node
+            @leading_comment = leading_comment
+            @type_annotation = type_annotation
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_location
+            case node
+            when Prism::ConstantWriteNode
+              rbs_location(node.name_loc)
+            when Prism::ConstantPathWriteNode
+              rbs_location(node.target.location)
+            end
+          end
+
+          def type
+            return type_annotation.type if type_annotation
+
+            case node.value
+            when Prism::IntegerNode
+              BuiltinNames::Integer.instance_type
+            when Prism::FloatNode
+              BuiltinNames::Float.instance_type
+            when Prism::StringNode
+              BuiltinNames::String.instance_type
+            when Prism::TrueNode, Prism::FalseNode
+              Types::Bases::Bool.new(location: nil)
+            when Prism::SymbolNode
+              BuiltinNames::Symbol.instance_type
+            when Prism::NilNode
+              Types::Bases::Nil.new(location: nil)
+            else
+              Types::Bases::Any.new(location: nil)
+            end
+          end
+
+          def comment
+            leading_comment&.as_comment
+          end
+
+          def type_fingerprint
+            [
+              "decls/constant",
+              constant_name.to_s,
+              type.to_s,
+              leading_comment&.as_comment&.string
+            ]
+          end
+        end
+
+        class ClassModuleAliasDecl < Base
+          attr_reader :node
+          attr_reader :leading_comment
+          attr_reader :new_name
+          attr_reader :infered_old_name
+          attr_reader :annotation
+
+          def initialize(buffer, node, new_name, infered_old_name, leading_comment, annotation)
+            super(buffer)
+            @node = node
+            @new_name = new_name
+            @infered_old_name = infered_old_name
+            @leading_comment = leading_comment
+            @annotation = annotation
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_location
+            case node
+            when Prism::ConstantWriteNode
+              rbs_location(node.name_loc)
+            when Prism::ConstantPathWriteNode
+              rbs_location(node.target.location)
+            end
+          end
+
+          def old_name
+            # Return explicit type name from annotation if provided, otherwise use inferred name
+            case
+            when annotation.type_name
+              annotation.type_name
+            when infered_old_name
+              infered_old_name
+            else
+              raise "No old name available"
+            end
+          end
+
+          def comment
+            leading_comment&.as_comment
+          end
+
+          def type_fingerprint
+            [
+              "decls/class_module_alias",
+              annotation.type_fingerprint,
+              new_name.to_s,
+              old_name.to_s,
+              leading_comment&.as_comment&.string
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/ast/ruby/helpers/constant_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Helpers
+        module ConstantHelper
+          module_function
+
+          def constant_as_type_name(node)
+            case node
+            when Prism::ConstantPathNode, Prism::ConstantReadNode
+              begin
+                TypeName.parse(node.full_name)
+              rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+                nil
+              end
+            when Prism::ConstantWriteNode
+              TypeName.new(name: node.name, namespace: Namespace.empty)
+            when Prism::ConstantPathWriteNode
+              constant_as_type_name(node.target)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/ast/ruby/helpers/location_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Helpers
+        module LocationHelper
+          def rbs_location(location)
+            Location.new(buffer, location.start_character_offset, location.end_character_offset)
+          end
+        end
+      end
+    end
+  end
+end