ed-precompiled_prism 1.5.2

data/lib/prism/pack.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+# :markup: markdown
+# typed: ignore
+
+#
+module Prism
+  # A parser for the pack template language.
+  module Pack
+    %i[
+      SPACE
+      COMMENT
+      INTEGER
+      UTF8
+      BER
+      FLOAT
+      STRING_SPACE_PADDED
+      STRING_NULL_PADDED
+      STRING_NULL_TERMINATED
+      STRING_MSB
+      STRING_LSB
+      STRING_HEX_HIGH
+      STRING_HEX_LOW
+      STRING_UU
+      STRING_MIME
+      STRING_BASE64
+      STRING_FIXED
+      STRING_POINTER
+      MOVE
+      BACK
+      NULL
+
+      UNSIGNED
+      SIGNED
+      SIGNED_NA
+
+      AGNOSTIC_ENDIAN
+      LITTLE_ENDIAN
+      BIG_ENDIAN
+      NATIVE_ENDIAN
+      ENDIAN_NA
+
+      SIZE_SHORT
+      SIZE_INT
+      SIZE_LONG
+      SIZE_LONG_LONG
+      SIZE_8
+      SIZE_16
+      SIZE_32
+      SIZE_64
+      SIZE_P
+      SIZE_NA
+
+      LENGTH_FIXED
+      LENGTH_MAX
+      LENGTH_RELATIVE
+      LENGTH_NA
+    ].each do |const|
+      const_set(const, const)
+    end
+
+    # A directive in the pack template language.
+    class Directive
+      # A symbol representing the version of Ruby.
+      attr_reader :version
+
+      # A symbol representing whether or not we are packing or unpacking.
+      attr_reader :variant
+
+      # A byteslice of the source string that this directive represents.
+      attr_reader :source
+
+      # The type of the directive.
+      attr_reader :type
+
+      # The type of signedness of the directive.
+      attr_reader :signed
+
+      # The type of endianness of the directive.
+      attr_reader :endian
+
+      # The size of the directive.
+      attr_reader :size
+
+      # The length type of this directive (used for integers).
+      attr_reader :length_type
+
+      # The length of this directive (used for integers).
+      attr_reader :length
+
+      # Initialize a new directive with the given values.
+      def initialize(version, variant, source, type, signed, endian, size, length_type, length)
+        @version = version
+        @variant = variant
+        @source = source
+        @type = type
+        @signed = signed
+        @endian = endian
+        @size = size
+        @length_type = length_type
+        @length = length
+      end
+
+      # The descriptions of the various types of endianness.
+      ENDIAN_DESCRIPTIONS = {
+        AGNOSTIC_ENDIAN: "agnostic",
+        LITTLE_ENDIAN: "little-endian (VAX)",
+        BIG_ENDIAN: "big-endian (network)",
+        NATIVE_ENDIAN: "native-endian",
+        ENDIAN_NA: "n/a"
+      }
+
+      # The descriptions of the various types of signedness.
+      SIGNED_DESCRIPTIONS = {
+        UNSIGNED: "unsigned",
+        SIGNED: "signed",
+        SIGNED_NA: "n/a"
+      }
+
+      # The descriptions of the various types of sizes.
+      SIZE_DESCRIPTIONS = {
+        SIZE_SHORT: "short",
+        SIZE_INT: "int-width",
+        SIZE_LONG: "long",
+        SIZE_LONG_LONG: "long long",
+        SIZE_8: "8-bit",
+        SIZE_16: "16-bit",
+        SIZE_32: "32-bit",
+        SIZE_64: "64-bit",
+        SIZE_P: "pointer-width"
+      }
+
+      # Provide a human-readable description of the directive.
+      def describe
+        case type
+        when SPACE
+          "whitespace"
+        when COMMENT
+          "comment"
+        when INTEGER
+          if size == SIZE_8
+            base = "#{SIGNED_DESCRIPTIONS[signed]} #{SIZE_DESCRIPTIONS[size]} integer"
+          else
+            base = "#{SIGNED_DESCRIPTIONS[signed]} #{SIZE_DESCRIPTIONS[size]} #{ENDIAN_DESCRIPTIONS[endian]} integer"
+          end
+          case length_type
+          when LENGTH_FIXED
+            if length > 1
+              base + ", x#{length}"
+            else
+              base
+            end
+          when LENGTH_MAX
+            base + ", as many as possible"
+          else
+            raise
+          end
+        when UTF8
+          "UTF-8 character"
+        when BER
+          "BER-compressed integer"
+        when FLOAT
+          "#{SIZE_DESCRIPTIONS[size]} #{ENDIAN_DESCRIPTIONS[endian]} float"
+        when STRING_SPACE_PADDED
+          "arbitrary binary string (space padded)"
+        when STRING_NULL_PADDED
+          "arbitrary binary string (null padded, count is width)"
+        when STRING_NULL_TERMINATED
+          "arbitrary binary string (null padded, count is width), except that null is added with *"
+        when STRING_MSB
+          "bit string (MSB first)"
+        when STRING_LSB
+          "bit string (LSB first)"
+        when STRING_HEX_HIGH
+          "hex string (high nibble first)"
+        when STRING_HEX_LOW
+          "hex string (low nibble first)"
+        when STRING_UU
+          "UU-encoded string"
+        when STRING_MIME
+          "quoted printable, MIME encoding"
+        when STRING_BASE64
+          "base64 encoded string"
+        when STRING_FIXED
+          "pointer to a structure (fixed-length string)"
+        when STRING_POINTER
+          "pointer to a null-terminated string"
+        when MOVE
+          "move to absolute position"
+        when BACK
+          "back up a byte"
+        when NULL
+          "null byte"
+        else
+          raise
+        end
+      end
+    end
+
+    # The result of parsing a pack template.
+    class Format
+      # A list of the directives in the template.
+      attr_reader :directives
+
+      # The encoding of the template.
+      attr_reader :encoding
+
+      # Create a new Format with the given directives and encoding.
+      def initialize(directives, encoding)
+        @directives = directives
+        @encoding = encoding
+      end
+
+      # Provide a human-readable description of the format.
+      def describe
+        source_width = directives.map { |d| d.source.inspect.length }.max
+        directive_lines = directives.map do |directive|
+          if directive.type == SPACE
+            source = directive.source.inspect
+          else
+            source = directive.source
+          end
+          # @type var source_width: Integer
+          "  #{source.ljust(source_width)}  #{directive.describe}"
+        end
+
+        (["Directives:"] + directive_lines + ["Encoding:", "  #{encoding}"]).join("\n")
+      end
+    end
+  end
+end

data/lib/prism/parse_result/comments.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+# :markup: markdown
+
+module Prism
+  class ParseResult < Result
+    # When we've parsed the source, we have both the syntax tree and the list of
+    # comments that we found in the source. This class is responsible for
+    # walking the tree and finding the nearest location to attach each comment.
+    #
+    # It does this by first finding the nearest locations to each comment.
+    # Locations can either come from nodes directly or from location fields on
+    # nodes. For example, a `ClassNode` has an overall location encompassing the
+    # entire class, but it also has a location for the `class` keyword.
+    #
+    # Once the nearest locations are found, it determines which one to attach
+    # to. If it's a trailing comment (a comment on the same line as other source
+    # code), it will favor attaching to the nearest location that occurs before
+    # the comment. Otherwise it will favor attaching to the nearest location
+    # that is after the comment.
+    class Comments
+      # A target for attaching comments that is based on a specific node's
+      # location.
+      class NodeTarget # :nodoc:
+        attr_reader :node
+
+        def initialize(node)
+          @node = node
+        end
+
+        def start_offset
+          node.start_offset
+        end
+
+        def end_offset
+          node.end_offset
+        end
+
+        def encloses?(comment)
+          start_offset <= comment.location.start_offset &&
+            comment.location.end_offset <= end_offset
+        end
+
+        def leading_comment(comment)
+          node.location.leading_comment(comment)
+        end
+
+        def trailing_comment(comment)
+          node.location.trailing_comment(comment)
+        end
+      end
+
+      # A target for attaching comments that is based on a location field on a
+      # node. For example, the `end` token of a ClassNode.
+      class LocationTarget # :nodoc:
+        attr_reader :location
+
+        def initialize(location)
+          @location = location
+        end
+
+        def start_offset
+          location.start_offset
+        end
+
+        def end_offset
+          location.end_offset
+        end
+
+        def encloses?(comment)
+          false
+        end
+
+        def leading_comment(comment)
+          location.leading_comment(comment)
+        end
+
+        def trailing_comment(comment)
+          location.trailing_comment(comment)
+        end
+      end
+
+      # The parse result that we are attaching comments to.
+      attr_reader :parse_result
+
+      # Create a new Comments object that will attach comments to the given
+      # parse result.
+      def initialize(parse_result)
+        @parse_result = parse_result
+      end
+
+      # Attach the comments to their respective locations in the tree by
+      # mutating the parse result.
+      def attach!
+        parse_result.comments.each do |comment|
+          preceding, enclosing, following = nearest_targets(parse_result.value, comment)
+
+          if comment.trailing?
+            if preceding
+              preceding.trailing_comment(comment)
+            else
+              (following || enclosing || NodeTarget.new(parse_result.value)).leading_comment(comment)
+            end
+          else
+            # If a comment exists on its own line, prefer a leading comment.
+            if following
+              following.leading_comment(comment)
+            elsif preceding
+              preceding.trailing_comment(comment)
+            else
+              (enclosing || NodeTarget.new(parse_result.value)).leading_comment(comment)
+            end
+          end
+        end
+      end
+
+      private
+
+      # Responsible for finding the nearest targets to the given comment within
+      # the context of the given encapsulating node.
+      def nearest_targets(node, comment)
+        comment_start = comment.location.start_offset
+        comment_end = comment.location.end_offset
+
+        targets = [] #: Array[_Target]
+        node.comment_targets.map do |value|
+          case value
+          when StatementsNode
+            targets.concat(value.body.map { |node| NodeTarget.new(node) })
+          when Node
+            targets << NodeTarget.new(value)
+          when Location
+            targets << LocationTarget.new(value)
+          end
+        end
+
+        targets.sort_by!(&:start_offset)
+        preceding = nil #: _Target?
+        following = nil #: _Target?
+
+        left = 0
+        right = targets.length
+
+        # This is a custom binary search that finds the nearest nodes to the
+        # given comment. When it finds a node that completely encapsulates the
+        # comment, it recurses downward into the tree.
+        while left < right
+          middle = (left + right) / 2
+          target = targets[middle]
+
+          target_start = target.start_offset
+          target_end = target.end_offset
+
+          if target.encloses?(comment)
+            # @type var target: NodeTarget
+            # The comment is completely contained by this target. Abandon the
+            # binary search at this level.
+            return nearest_targets(target.node, comment)
+          end
+
+          if target_end <= comment_start
+            # This target falls completely before the comment. Because we will
+            # never consider this target or any targets before it again, this
+            # target must be the closest preceding target we have encountered so
+            # far.
+            preceding = target
+            left = middle + 1
+            next
+          end
+
+          if comment_end <= target_start
+            # This target falls completely after the comment. Because we will
+            # never consider this target or any targets after it again, this
+            # target must be the closest following target we have encountered so
+            # far.
+            following = target
+            right = middle
+            next
+          end
+
+          # This should only happen if there is a bug in this parser.
+          raise "Comment location overlaps with a target location"
+        end
+
+        [preceding, NodeTarget.new(node), following]
+      end
+    end
+  end
+end

data/lib/prism/parse_result/errors.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# :markup: markdown
+
+require "stringio"
+
+module Prism
+  class ParseResult < Result
+    # An object to represent the set of errors on a parse result. This object
+    # can be used to format the errors in a human-readable way.
+    class Errors
+      # The parse result that contains the errors.
+      attr_reader :parse_result
+
+      # Initialize a new set of errors from the given parse result.
+      def initialize(parse_result)
+        @parse_result = parse_result
+      end
+
+      # Formats the errors in a human-readable way and return them as a string.
+      def format
+        error_lines = {} #: Hash[Integer, Array[ParseError]]
+        parse_result.errors.each do |error|
+          location = error.location
+          (location.start_line..location.end_line).each do |line|
+            error_lines[line] ||= []
+            error_lines[line] << error
+          end
+        end
+
+        source_lines = parse_result.source.source.lines
+        source_lines << "" if error_lines.key?(source_lines.size + 1)
+
+        io = StringIO.new
+        source_lines.each.with_index(1) do |line, line_number|
+          io.puts(line)
+
+          (error_lines.delete(line_number) || []).each do |error|
+            location = error.location
+
+            case line_number
+            when location.start_line
+              io.print(" " * location.start_column + "^")
+
+              if location.start_line == location.end_line
+                if location.start_column != location.end_column
+                  io.print("~" * (location.end_column - location.start_column - 1))
+                end
+
+                io.puts(" " + error.message)
+              else
+                io.puts("~" * (line.bytesize - location.start_column))
+              end
+            when location.end_line
+              io.puts("~" * location.end_column + " " + error.message)
+            else
+              io.puts("~" * line.bytesize)
+            end
+          end
+        end
+
+        io.puts
+        io.string
+      end
+    end
+  end
+end

data/lib/prism/parse_result/newlines.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+# :markup: markdown
+
+module Prism
+  class ParseResult < Result
+    # The :line tracepoint event gets fired whenever the Ruby VM encounters an
+    # expression on a new line. The types of expressions that can trigger this
+    # event are:
+    #
+    # * if statements
+    # * unless statements
+    # * nodes that are children of statements lists
+    #
+    # In order to keep track of the newlines, we have a list of offsets that
+    # come back from the parser. We assign these offsets to the first nodes that
+    # we find in the tree that are on those lines.
+    #
+    # Note that the logic in this file should be kept in sync with the Java
+    # MarkNewlinesVisitor, since that visitor is responsible for marking the
+    # newlines for JRuby/TruffleRuby.
+    #
+    # This file is autoloaded only when `mark_newlines!` is called, so the
+    # re-opening of the various nodes in this file will only be performed in
+    # that case. We do that to avoid storing the extra `@newline` instance
+    # variable on every node if we don't need it.
+    class Newlines < Visitor
+      # Create a new Newlines visitor with the given newline offsets.
+      def initialize(lines)
+        # @type var lines: Integer
+        @lines = Array.new(1 + lines, false)
+      end
+
+      # Permit block/lambda nodes to mark newlines within themselves.
+      def visit_block_node(node)
+        old_lines = @lines
+        @lines = Array.new(old_lines.size, false)
+
+        begin
+          super(node)
+        ensure
+          @lines = old_lines
+        end
+      end
+
+      alias_method :visit_lambda_node, :visit_block_node
+
+      # Mark if/unless nodes as newlines.
+      def visit_if_node(node)
+        node.newline_flag!(@lines)
+        super(node)
+      end
+
+      alias_method :visit_unless_node, :visit_if_node
+
+      # Permit statements lists to mark newlines within themselves.
+      def visit_statements_node(node)
+        node.body.each do |child|
+          child.newline_flag!(@lines)
+        end
+        super(node)
+      end
+    end
+  end
+
+  class Node
+    def newline_flag? # :nodoc:
+      !!defined?(@newline_flag)
+    end
+
+    def newline_flag!(lines) # :nodoc:
+      line = location.start_line
+      unless lines[line]
+        lines[line] = true
+        @newline_flag = true
+      end
+    end
+  end
+
+  class BeginNode < Node
+    def newline_flag!(lines) # :nodoc:
+      # Never mark BeginNode with a newline flag, mark children instead.
+    end
+  end
+
+  class ParenthesesNode < Node
+    def newline_flag!(lines) # :nodoc:
+      # Never mark ParenthesesNode with a newline flag, mark children instead.
+    end
+  end
+
+  class IfNode < Node
+    def newline_flag!(lines) # :nodoc:
+      predicate.newline_flag!(lines)
+    end
+  end
+
+  class UnlessNode < Node
+    def newline_flag!(lines) # :nodoc:
+      predicate.newline_flag!(lines)
+    end
+  end
+
+  class UntilNode < Node
+    def newline_flag!(lines) # :nodoc:
+      predicate.newline_flag!(lines)
+    end
+  end
+
+  class WhileNode < Node
+    def newline_flag!(lines) # :nodoc:
+      predicate.newline_flag!(lines)
+    end
+  end
+
+  class RescueModifierNode < Node
+    def newline_flag!(lines) # :nodoc:
+      expression.newline_flag!(lines)
+    end
+  end
+
+  class InterpolatedMatchLastLineNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
+    end
+  end
+
+  class InterpolatedRegularExpressionNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
+    end
+  end
+
+  class InterpolatedStringNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
+    end
+  end
+
+  class InterpolatedSymbolNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
+    end
+  end
+
+  class InterpolatedXStringNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
+    end
+  end
+end