yarp 0.12.0 → 0.13.0

data/lib/prism/node_ext.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Here we are reopening the prism module to provide methods on nodes that aren't
+# templated and are meant as convenience methods.
+module Prism
+  class FloatNode < Node
+    # Returns the value of the node as a Ruby Float.
+    def value
+      Float(slice)
+    end
+  end
+
+  class ImaginaryNode < Node
+    # Returns the value of the node as a Ruby Complex.
+    def value
+      Complex(0, numeric.value)
+    end
+  end
+
+  class IntegerNode < Node
+    # Returns the value of the node as a Ruby Integer.
+    def value
+      Integer(slice)
+    end
+  end
+
+  class InterpolatedRegularExpressionNode < Node
+    # Returns a numeric value that represents the flags that were used to create
+    # the regular expression.
+    def options
+      o = flags & (RegularExpressionFlags::IGNORE_CASE | RegularExpressionFlags::EXTENDED | RegularExpressionFlags::MULTI_LINE)
+      o |= Regexp::FIXEDENCODING if flags.anybits?(RegularExpressionFlags::EUC_JP | RegularExpressionFlags::WINDOWS_31J | RegularExpressionFlags::UTF_8)
+      o |= Regexp::NOENCODING if flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
+      o
+    end
+  end
+
+  class RationalNode < Node
+    # Returns the value of the node as a Ruby Rational.
+    def value
+      Rational(slice.chomp("r"))
+    end
+  end
+
+  class RegularExpressionNode < Node
+    # Returns a numeric value that represents the flags that were used to create
+    # the regular expression.
+    def options
+      o = flags & (RegularExpressionFlags::IGNORE_CASE | RegularExpressionFlags::EXTENDED | RegularExpressionFlags::MULTI_LINE)
+      o |= Regexp::FIXEDENCODING if flags.anybits?(RegularExpressionFlags::EUC_JP | RegularExpressionFlags::WINDOWS_31J | RegularExpressionFlags::UTF_8)
+      o |= Regexp::NOENCODING if flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
+      o
+    end
+  end
+end

data/lib/prism/node_inspector.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Prism
+  # This object is responsible for generating the output for the inspect method
+  # implementations of child nodes.
+  class NodeInspector
+    attr_reader :prefix, :output
+
+    def initialize(prefix = "")
+      @prefix = prefix
+      @output = +""
+    end
+
+    # Appends a line to the output with the current prefix.
+    def <<(line)
+      output << "#{prefix}#{line}"
+    end
+
+    # This generates a string that is used as the header of the inspect output
+    # for any given node.
+    def header(node)
+      output = +"@ #{node.class.name.split("::").last} ("
+      output << "location: (#{node.location.start_line},#{node.location.start_column})-(#{node.location.end_line},#{node.location.end_column})"
+      output << ", newline: true" if node.newline?
+      output << ")\n"
+      output
+    end
+
+    # Generates a string that represents a list of nodes. It handles properly
+    # using the box drawing characters to make the output look nice.
+    def list(prefix, nodes)
+      output = +"(length: #{nodes.length})\n"
+      last_index = nodes.length - 1
+
+      nodes.each_with_index do |node, index|
+        pointer, preadd = (index == last_index) ? ["└── ", "    "] : ["├── ", "│   "]
+        node_prefix = "#{prefix}#{preadd}"
+        output << node.inspect(NodeInspector.new(node_prefix)).sub(node_prefix, "#{prefix}#{pointer}")
+      end
+
+      output
+    end
+
+    # Generates a string that represents a location field on a node.
+    def location(value)
+      if value
+        "(#{value.start_line},#{value.start_column})-(#{value.end_line},#{value.end_column}) = #{value.slice.inspect}"
+      else
+        "∅"
+      end
+    end
+
+    # Generates a string that represents a child node.
+    def child_node(node, append)
+      node.inspect(child_inspector(append)).delete_prefix(prefix)
+    end
+
+    # Returns a new inspector that can be used to inspect a child node.
+    def child_inspector(append)
+      NodeInspector.new("#{prefix}#{append}")
+    end
+
+    # Returns the output as a string.
+    def to_str
+      output
+    end
+  end
+end

data/lib/{yarp → prism}/pack.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module YARP
+module Prism
   module Pack
     %i[
       SPACE

data/lib/{yarp → prism}/parse_result/comments.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module YARP
+module Prism
   class ParseResult
     # 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

data/lib/{yarp → prism}/parse_result/newlines.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module YARP
+module Prism
   class ParseResult
     # 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

data/lib/prism/parse_result.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module Prism
+  # This represents a source of Ruby code that has been parsed. It is used in
+  # conjunction with locations to allow them to resolve line numbers and source
+  # ranges.
+  class Source
+    attr_reader :source, :offsets
+
+    def initialize(source, offsets = compute_offsets(source))
+      @source = source
+      @offsets = offsets
+    end
+
+    def slice(offset, length)
+      source.byteslice(offset, length)
+    end
+
+    def line(value)
+      offsets.bsearch_index { |offset| offset > value } || offsets.length
+    end
+
+    def line_offset(value)
+      offsets[line(value) - 1]
+    end
+
+    def column(value)
+      value - offsets[line(value) - 1]
+    end
+
+    private
+
+    def compute_offsets(code)
+      offsets = [0]
+      code.b.scan("\n") { offsets << $~.end(0) }
+      offsets
+    end
+  end
+
+  # This represents a location in the source.
+  class Location
+    # A Source object that is used to determine more information from the given
+    # offset and length.
+    protected attr_reader :source
+
+    # The byte offset from the beginning of the source where this location
+    # starts.
+    attr_reader :start_offset
+
+    # The length of this location in bytes.
+    attr_reader :length
+
+    # The list of comments attached to this location
+    attr_reader :comments
+
+    def initialize(source, start_offset, length)
+      @source = source
+      @start_offset = start_offset
+      @length = length
+      @comments = []
+    end
+
+    # Create a new location object with the given options.
+    def copy(**options)
+      Location.new(
+        options.fetch(:source) { source },
+        options.fetch(:start_offset) { start_offset },
+        options.fetch(:length) { length }
+      )
+    end
+
+    # Returns a string representation of this location.
+    def inspect
+      "#<Prism::Location @start_offset=#{@start_offset} @length=#{@length} start_line=#{start_line}>"
+    end
+
+    # The source code that this location represents.
+    def slice
+      source.slice(start_offset, length)
+    end
+
+    # The byte offset from the beginning of the source where this location ends.
+    def end_offset
+      start_offset + length
+    end
+
+    # The line number where this location starts.
+    def start_line
+      source.line(start_offset)
+    end
+
+    # The content of the line where this location starts before this location.
+    def start_line_slice
+      offset = source.line_offset(start_offset)
+      source.slice(offset, start_offset - offset)
+    end
+
+    # The line number where this location ends.
+    def end_line
+      source.line(end_offset - 1)
+    end
+
+    # The column number in bytes where this location starts from the start of
+    # the line.
+    def start_column
+      source.column(start_offset)
+    end
+
+    # The column number in bytes where this location ends from the start of the
+    # line.
+    def end_column
+      source.column(end_offset)
+    end
+
+    def deconstruct_keys(keys)
+      { start_offset: start_offset, end_offset: end_offset }
+    end
+
+    def pretty_print(q)
+      q.text("(#{start_line},#{start_column})-(#{end_line},#{end_column}))")
+    end
+
+    def ==(other)
+      other.is_a?(Location) &&
+        other.start_offset == start_offset &&
+        other.end_offset == end_offset
+    end
+
+    # Returns a new location that stretches from this location to the given
+    # other location. Raises an error if this location is not before the other
+    # location or if they don't share the same source.
+    def join(other)
+      raise "Incompatible sources" if source != other.source
+      raise "Incompatible locations" if start_offset > other.start_offset
+
+      Location.new(source, start_offset, other.end_offset - start_offset)
+    end
+
+    def self.null
+      new(0, 0)
+    end
+  end
+
+  # This represents a comment that was encountered during parsing.
+  class Comment
+    TYPES = [:inline, :embdoc, :__END__]
+
+    attr_reader :type, :location
+
+    def initialize(type, location)
+      @type = type
+      @location = location
+    end
+
+    def deconstruct_keys(keys)
+      { type: type, location: location }
+    end
+
+    # Returns true if the comment happens on the same line as other code and false if the comment is by itself
+    def trailing?
+      type == :inline && !location.start_line_slice.strip.empty?
+    end
+
+    def inspect
+      "#<Prism::Comment @type=#{@type.inspect} @location=#{@location.inspect}>"
+    end
+  end
+
+  # This represents an error that was encountered during parsing.
+  class ParseError
+    attr_reader :message, :location
+
+    def initialize(message, location)
+      @message = message
+      @location = location
+    end
+
+    def deconstruct_keys(keys)
+      { message: message, location: location }
+    end
+
+    def inspect
+      "#<Prism::ParseError @message=#{@message.inspect} @location=#{@location.inspect}>"
+    end
+  end
+
+  # This represents a warning that was encountered during parsing.
+  class ParseWarning
+    attr_reader :message, :location
+
+    def initialize(message, location)
+      @message = message
+      @location = location
+    end
+
+    def deconstruct_keys(keys)
+      { message: message, location: location }
+    end
+
+    def inspect
+      "#<Prism::ParseWarning @message=#{@message.inspect} @location=#{@location.inspect}>"
+    end
+  end
+
+  # This represents the result of a call to ::parse or ::parse_file. It contains
+  # the AST, any comments that were encounters, and any errors that were
+  # encountered.
+  class ParseResult
+    attr_reader :value, :comments, :errors, :warnings, :source
+
+    def initialize(value, comments, errors, warnings, source)
+      @value = value
+      @comments = comments
+      @errors = errors
+      @warnings = warnings
+      @source = source
+    end
+
+    def deconstruct_keys(keys)
+      { value: value, comments: comments, errors: errors, warnings: warnings }
+    end
+
+    def success?
+      errors.empty?
+    end
+
+    def failure?
+      !success?
+    end
+  end
+
+  # This represents a token from the Ruby source.
+  class Token
+    attr_reader :type, :value, :location
+
+    def initialize(type, value, location)
+      @type = type
+      @value = value
+      @location = location
+    end
+
+    def deconstruct_keys(keys)
+      { type: type, value: value, location: location }
+    end
+
+    def pretty_print(q)
+      q.group do
+        q.text(type.to_s)
+        self.location.pretty_print(q)
+        q.text("(")
+        q.nest(2) do
+          q.breakable("")
+          q.pp(value)
+        end
+        q.breakable("")
+        q.text(")")
+      end
+    end
+
+    def ==(other)
+      other.is_a?(Token) &&
+        other.type == type &&
+        other.value == value
+    end
+  end
+end

data/lib/{yarp → prism}/pattern.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-module YARP
+module Prism
   # A pattern is an object that wraps a Ruby pattern matching expression. The
   # expression would normally be passed to an `in` clause within a `case`
   # expression or a rightward assignment expression. For example, in the
   # following snippet:
   #
   #     case node
-  #     in ConstantPathNode[ConstantReadNode[name: :YARP], ConstantReadNode[name: :Pattern]]
+  #     in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
   #     end
   #
   # the pattern is the `ConstantPathNode[...]` expression.
   #
   # The pattern gets compiled into an object that responds to #call by running
-  # the #compile method. This method itself will run back through YARP to
+  # the #compile method. This method itself will run back through Prism to
   # parse the expression into a tree, then walk the tree to generate the
   # necessary callable objects. For example, if you wanted to compile the
   # expression above into a callable, you would:
   #
-  #     callable = YARP::Pattern.new("ConstantPathNode[ConstantReadNode[name: :YARP], ConstantReadNode[name: :Pattern]]").compile
+  #     callable = Prism::Pattern.new("ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]").compile
   #     callable.call(node)
   #
   # The callable object returned by #compile is guaranteed to respond to #call
@@ -32,7 +32,7 @@ module YARP
   #
   # If the query given to the initializer cannot be compiled into a valid
   # matcher (either because of a syntax error or because it is using syntax we
-  # do not yet support) then a YARP::Pattern::CompilationError will be
+  # do not yet support) then a Prism::Pattern::CompilationError will be
   # raised.
   class Pattern
     # Raised when the query given to a pattern is either invalid Ruby syntax or
@@ -40,15 +40,15 @@ module YARP
     class CompilationError < StandardError
       def initialize(repr)
         super(<<~ERROR)
-          YARP was unable to compile the pattern you provided into a usable
+          prism was unable to compile the pattern you provided into a usable
           expression. It failed on to understand the node represented by:
 
           #{repr}
 
           Note that not all syntax supported by Ruby's pattern matching syntax
-          is also supported by YARP's patterns. If you're using some syntax
+          is also supported by prism's patterns. If you're using some syntax
           that you believe should be supported, please open an issue on
-          GitHub at https://github.com/ruby/yarp/issues/new.
+          GitHub at https://github.com/ruby/prism/issues/new.
         ERROR
       end
     end
@@ -61,7 +61,7 @@ module YARP
     end
 
     def compile
-      result = YARP.parse("case nil\nin #{query}\nend")
+      result = Prism.parse("case nil\nin #{query}\nend")
       compile_node(result.value.statements.body.last.conditions.last.pattern)
     end
 
@@ -73,7 +73,7 @@ module YARP
 
       while (node = queue.shift)
         yield node if @compiled.call(node)
-        queue.concat(node.child_nodes.compact)
+        queue.concat(node.compact_child_nodes)
       end
     end
 
@@ -126,11 +126,11 @@ module YARP
       combine_or(compile_node(node.left), compile_node(node.right))
     end
 
-    # in YARP::ConstantReadNode
+    # in Prism::ConstantReadNode
     def compile_constant_path_node(node)
       parent = node.parent
 
-      if parent.is_a?(ConstantReadNode) && parent.slice == "YARP"
+      if parent.is_a?(ConstantReadNode) && parent.slice == "Prism"
         compile_node(node.child)
       else
         compile_error(node)
@@ -142,8 +142,8 @@ module YARP
     def compile_constant_read_node(node)
       value = node.slice
 
-      if YARP.const_defined?(value, false)
-        clazz = YARP.const_get(value)
+      if Prism.const_defined?(value, false)
+        clazz = Prism.const_get(value)
 
         ->(other) { clazz === other }
       elsif Object.const_defined?(value, false)

data/lib/{yarp → prism}/ripper_compat.rb

@@ -2,14 +2,14 @@
 
 require "ripper"
 
-module YARP
-  # This class is meant to provide a compatibility layer between YARP and
+module Prism
+  # This class is meant to provide a compatibility layer between prism and
   # Ripper. It functions by parsing the entire tree first and then walking it
   # and executing each of the Ripper callbacks as it goes.
   #
   # This class is going to necessarily be slower than the native Ripper API. It
-  # is meant as a stopgap until developers migrate to using YARP. It is also
-  # meant as a test harness for the YARP parser.
+  # is meant as a stopgap until developers migrate to using prism. It is also
+  # meant as a test harness for the prism parser.
   class RipperCompat
     # This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
     # returns the arrays of [type, *children].
@@ -156,7 +156,7 @@ module YARP
     end
 
     def result
-      @result ||= YARP.parse(source)
+      @result ||= Prism.parse(source)
     end
 
     def _dispatch0; end

data/lib/{yarp → prism}/serialize.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 =begin
 This file is generated by the templates/template.rb script and should not be
-modified manually. See templates/lib/yarp/serialize.rb.erb
+modified manually. See templates/lib/prism/serialize.rb.erb
 if you are looking to modify the template
 =end
 
@@ -18,10 +18,10 @@ if String.instance_method(:unpack1).parameters.none? { |_, name| name == :offset
   )
 end
 
-module YARP
+module Prism
   module Serialize
     MAJOR_VERSION = 0
-    MINOR_VERSION = 12
+    MINOR_VERSION = 13
     PATCH_VERSION = 0
 
     def self.load(input, serialized)
@@ -74,7 +74,7 @@ module YARP
           length = load_varint
           lex_state = load_varint
           location = Location.new(@source, start, length)
-          tokens << [YARP::Token.new(type, location.slice, location), lex_state]
+          tokens << [Prism::Token.new(type, location.slice, location), lex_state]
         end
 
         tokens
@@ -90,12 +90,16 @@ module YARP
         end
 
         raise "Expected to consume all bytes while deserializing" unless @io.eof?
-        YARP::ParseResult.new(tokens, comments, errors, warnings, @source)
+        Prism::ParseResult.new(tokens, comments, errors, warnings, @source)
       end
 
       def load_nodes
-        raise "Invalid serialization" if io.read(4) != "YARP"
+        raise "Invalid serialization" if io.read(5) != "PRISM"
         raise "Invalid serialization" if io.read(3).unpack("C3") != [MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION]
+        only_semantic_fields = io.read(1).unpack1("C")
+        unless only_semantic_fields == 0
+          raise "Invalid serialization (location fields must be included but are not)"
+        end
 
         @encoding = load_encoding
         @input = input.force_encoding(@encoding).freeze
@@ -110,7 +114,7 @@ module YARP
 
       def load_result
         node, comments, errors, warnings = load_nodes
-        YARP::ParseResult.new(node, comments, errors, warnings, @source)
+        Prism::ParseResult.new(node, comments, errors, warnings, @source)
       end
 
       private
@@ -605,6 +609,7 @@ module YARP
       :LESS_EQUAL_GREATER,
       :LESS_LESS,
       :LESS_LESS_EQUAL,
+      :METHOD_NAME,
       :MINUS,
       :MINUS_EQUAL,
       :MINUS_GREATER,