prism 0.17.1 → 0.19.0

data/lib/prism/node_ext.rb

@@ -14,8 +14,49 @@ module Prism
     end
   end
 
+  class InterpolatedMatchLastLineNode < Node
+    include RegularExpressionOptions
+  end
+
+  class InterpolatedRegularExpressionNode < Node
+    include RegularExpressionOptions
+  end
+
+  class MatchLastLineNode < Node
+    include RegularExpressionOptions
+  end
+
+  class RegularExpressionNode < Node
+    include RegularExpressionOptions
+  end
+
   private_constant :RegularExpressionOptions
 
+  module HeredocQuery # :nodoc:
+    # Returns true if this node was represented as a heredoc in the source code.
+    def heredoc?
+      opening&.start_with?("<<")
+    end
+  end
+
+  class InterpolatedStringNode < Node
+    include HeredocQuery
+  end
+
+  class InterpolatedXStringNode < Node
+    include HeredocQuery
+  end
+
+  class StringNode < Node
+    include HeredocQuery
+  end
+
+  class XStringNode < Node
+    include HeredocQuery
+  end
+
+  private_constant :HeredocQuery
+
   class FloatNode < Node
     # Returns the value of the node as a Ruby Float.
     def value
@@ -37,18 +78,6 @@ module Prism
     end
   end
 
-  class InterpolatedMatchLastLineNode < Node
-    include RegularExpressionOptions
-  end
-
-  class InterpolatedRegularExpressionNode < Node
-    include RegularExpressionOptions
-  end
-
-  class MatchLastLineNode < Node
-    include RegularExpressionOptions
-  end
-
   class RationalNode < Node
     # Returns the value of the node as a Ruby Rational.
     def value
@@ -56,12 +85,9 @@ module Prism
     end
   end
 
-  class RegularExpressionNode < Node
-    include RegularExpressionOptions
-  end
-
   class ConstantReadNode < Node
-    # Returns the list of parts for the full name of this constant. For example: [:Foo]
+    # Returns the list of parts for the full name of this constant.
+    # For example: [:Foo]
     def full_name_parts
       [name]
     end
@@ -73,7 +99,16 @@ module Prism
   end
 
   class ConstantPathNode < Node
-    # Returns the list of parts for the full name of this constant path. For example: [:Foo, :Bar]
+    # An error class raised when dynamic parts are found while computing a
+    # constant path's full name. For example:
+    # Foo::Bar::Baz -> does not raise because all parts of the constant path are
+    # simple constants
+    # var::Bar::Baz -> raises because the first part of the constant path is a
+    # local variable
+    class DynamicPartsInConstantPathError < StandardError; end
+
+    # Returns the list of parts for the full name of this constant path.
+    # For example: [:Foo, :Bar]
     def full_name_parts
       parts = [child.name]
       current = parent
@@ -83,6 +118,10 @@ module Prism
         current = current.parent
       end
 
+      unless current.is_a?(ConstantReadNode)
+        raise DynamicPartsInConstantPathError, "Constant path contains dynamic parts. Cannot compute full name"
+      end
+
       parts.unshift(current&.name || :"")
     end
 
@@ -93,7 +132,8 @@ module Prism
   end
 
   class ConstantPathTargetNode < Node
-    # Returns the list of parts for the full name of this constant path. For example: [:Foo, :Bar]
+    # Returns the list of parts for the full name of this constant path.
+    # For example: [:Foo, :Bar]
     def full_name_parts
       (parent&.full_name_parts || [:""]).push(child.name)
     end
@@ -103,4 +143,47 @@ module Prism
       full_name_parts.join("::")
     end
   end
+
+  class ParametersNode < Node
+    # Mirrors the Method#parameters method.
+    def signature
+      names = []
+
+      requireds.each do |param|
+        names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name])
+      end
+
+      optionals.each { |param| names << [:opt, param.name] }
+      names << [:rest, rest.name || :*] if rest
+
+      posts.each do |param|
+        names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name])
+      end
+
+      # Regardless of the order in which the keywords were defined, the required
+      # keywords always come first followed by the optional keywords.
+      keyopt = []
+      keywords.each do |param|
+        if param.is_a?(OptionalKeywordParameterNode)
+          keyopt << param
+        else
+          names << [:keyreq, param.name]
+        end
+      end
+
+      keyopt.each { |param| names << [:key, param.name] }
+
+      case keyword_rest
+      when ForwardingParameterNode
+        names.concat([[:rest, :*], [:keyrest, :**], [:block, :&]])
+      when KeywordRestParameterNode
+        names << [:keyrest, keyword_rest.name || :**]
+      when NoKeywordsParameterNode
+        names << [:nokey]
+      end
+
+      names << [:block, block.name || :&] if block
+      names
+    end
+  end
 end

data/lib/prism/parse_result.rb

@@ -25,40 +25,50 @@ module Prism
 
     # Perform a byteslice on the source code using the given byte offset and
     # byte length.
-    def slice(offset, length)
-      source.byteslice(offset, length)
+    def slice(byte_offset, length)
+      source.byteslice(byte_offset, length)
     end
 
     # Binary search through the offsets to find the line number for the given
     # byte offset.
-    def line(value)
-      start_line + find_line(value)
+    def line(byte_offset)
+      start_line + find_line(byte_offset)
     end
 
     # Return the byte offset of the start of the line corresponding to the given
     # byte offset.
-    def line_offset(value)
-      offsets[find_line(value)]
+    def line_start(byte_offset)
+      offsets[find_line(byte_offset)]
     end
 
     # Return the column number for the given byte offset.
-    def column(value)
-      value - offsets[find_line(value)]
+    def column(byte_offset)
+      byte_offset - line_start(byte_offset)
+    end
+
+    # Return the character offset for the given byte offset.
+    def character_offset(byte_offset)
+      source.byteslice(0, byte_offset).length
+    end
+
+    # Return the column number in characters for the given byte offset.
+    def character_column(byte_offset)
+      character_offset(byte_offset) - character_offset(line_start(byte_offset))
     end
 
     private
 
     # Binary search through the offsets to find the line number for the given
     # byte offset.
-    def find_line(value)
+    def find_line(byte_offset)
       left = 0
       right = offsets.length - 1
 
       while left <= right
         mid = left + (right - left) / 2
-        return mid if offsets[mid] == value
+        return mid if offsets[mid] == byte_offset
 
-        if offsets[mid] < value
+        if offsets[mid] < byte_offset
           left = mid + 1
         else
           right = mid - 1
@@ -121,11 +131,23 @@ module Prism
       source.slice(start_offset, length)
     end
 
+    # The character offset from the beginning of the source where this location
+    # starts.
+    def start_character_offset
+      source.character_offset(start_offset)
+    end
+
     # The byte offset from the beginning of the source where this location ends.
     def end_offset
       start_offset + length
     end
 
+    # The character offset from the beginning of the source where this location
+    # ends.
+    def end_character_offset
+      source.character_offset(end_offset)
+    end
+
     # The line number where this location starts.
     def start_line
       source.line(start_offset)
@@ -133,7 +155,7 @@ module Prism
 
     # The content of the line where this location starts before this location.
     def start_line_slice
-      offset = source.line_offset(start_offset)
+      offset = source.line_start(start_offset)
       source.slice(offset, start_offset - offset)
     end
 
@@ -148,12 +170,24 @@ module Prism
       source.column(start_offset)
     end
 
+    # The column number in characters where this location ends from the start of
+    # the line.
+    def start_character_column
+      source.character_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
 
+    # The column number in characters where this location ends from the start of
+    # the line.
+    def end_character_column
+      source.character_column(end_offset)
+    end
+
     # Implement the hash pattern matching interface for Location.
     def deconstruct_keys(keys)
       { start_offset: start_offset, end_offset: end_offset }
@@ -204,11 +238,6 @@ module Prism
     def deconstruct_keys(keys)
       { location: location }
     end
-
-    # This can only be true for inline comments.
-    def trailing?
-      false
-    end
   end
 
   # InlineComment objects are the most common. They correspond to comments in
@@ -229,18 +258,14 @@ module Prism
   # EmbDocComment objects correspond to comments that are surrounded by =begin
   # and =end.
   class EmbDocComment < Comment
-    # Returns a string representation of this comment.
-    def inspect
-      "#<Prism::EmbDocComment @location=#{location.inspect}>"
+    # This can only be true for inline comments.
+    def trailing?
+      false
     end
-  end
 
-  # DATAComment objects correspond to comments that are after the __END__
-  # keyword in a source file.
-  class DATAComment < Comment
     # Returns a string representation of this comment.
     def inspect
-      "#<Prism::DATAComment @location=#{location.inspect}>"
+      "#<Prism::EmbDocComment @location=#{location.inspect}>"
     end
   end
 
@@ -344,6 +369,11 @@ module Prism
     # The list of magic comments that were encountered during parsing.
     attr_reader :magic_comments
 
+    # An optional location that represents the location of the content after the
+    # __END__ marker. This content is loaded into the DATA constant when the
+    # file being parsed is the main file being executed.
+    attr_reader :data_loc
+
     # The list of errors that were generated during parsing.
     attr_reader :errors
 
@@ -354,10 +384,11 @@ module Prism
     attr_reader :source
 
     # Create a new parse result object with the given values.
-    def initialize(value, comments, magic_comments, errors, warnings, source)
+    def initialize(value, comments, magic_comments, data_loc, errors, warnings, source)
       @value = value
       @comments = comments
       @magic_comments = magic_comments
+      @data_loc = data_loc
       @errors = errors
       @warnings = warnings
       @source = source
@@ -365,7 +396,7 @@ module Prism
 
     # Implement the hash pattern matching interface for ParseResult.
     def deconstruct_keys(keys)
-      { value: value, comments: comments, magic_comments: magic_comments, errors: errors, warnings: warnings }
+      { value: value, comments: comments, magic_comments: magic_comments, data_loc: data_loc, errors: errors, warnings: warnings }
     end
 
     # Returns true if there were no errors during parsing and false if there

data/lib/prism/ripper_compat.rb

@@ -3,6 +3,10 @@
 require "ripper"
 
 module Prism
+  # Note: This integration is not finished, and therefore still has many
+  # inconsistencies with Ripper. If you'd like to help out, pull requests would
+  # be greatly appreciated!
+  #
   # 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.
@@ -10,7 +14,10 @@ module Prism
   # This class is going to necessarily be slower than the native Ripper API. It
   # 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
+  #
+  # To use this class, you treat `Prism::RipperCompat` effectively as you would
+  # treat the `Ripper` class.
+  class RipperCompat < Visitor
     # This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
     # returns the arrays of [type, *children].
     class SexpBuilder < RipperCompat
@@ -77,43 +84,63 @@ module Prism
 
     # True if the parser encountered an error during parsing.
     def error?
-      result.errors.any?
+      result.failure?
     end
 
     # Parse the source and return the result.
     def parse
-      result.value.accept(self) unless error?
+      result.magic_comments.each do |magic_comment|
+        on_magic_comment(magic_comment.key, magic_comment.value)
+      end
+
+      if error?
+        result.errors.each do |error|
+          on_parse_error(error.message)
+        end
+      else
+        result.value.accept(self)
+      end
     end
 
     ############################################################################
     # Visitor methods
     ############################################################################
 
-    # This method is responsible for dispatching to the correct visitor method
-    # based on the type of the node.
-    def visit(node)
-      node&.accept(self)
-    end
-
     # Visit a CallNode node.
     def visit_call_node(node)
-      if !node.opening_loc && node.arguments.arguments.length == 1
-        bounds(node.receiver.location)
+      if !node.message.match?(/^[[:alpha:]_]/) && node.opening_loc.nil? && node.arguments&.arguments&.length == 1
         left = visit(node.receiver)
-
-        bounds(node.arguments.arguments.first.location)
         right = visit(node.arguments.arguments.first)
 
-        on_binary(left, source[node.message_loc.start_offset...node.message_loc.end_offset].to_sym, right)
+        bounds(node.location)
+        on_binary(left, node.name, right)
       else
         raise NotImplementedError
       end
     end
 
+    # Visit a FloatNode node.
+    def visit_float_node(node)
+      bounds(node.location)
+      on_float(node.slice)
+    end
+
+    # Visit a ImaginaryNode node.
+    def visit_imaginary_node(node)
+      bounds(node.location)
+      on_imaginary(node.slice)
+    end
+
     # Visit an IntegerNode node.
     def visit_integer_node(node)
       bounds(node.location)
-      on_int(source[node.location.start_offset...node.location.end_offset])
+      on_int(node.slice)
+    end
+
+    # Visit a RationalNode node.
+    def visit_rational_node(node)
+      bounds(node.location)
+      on_rational(node.slice)
     end
 
     # Visit a StatementsNode node.
@@ -124,24 +151,11 @@ module Prism
       end
     end
 
-    # Visit a token found during parsing.
-    def visit_token(node)
-      bounds(node.location)
-
-      case node.type
-      when :MINUS
-        on_op(node.value)
-      when :PLUS
-        on_op(node.value)
-      else
-        raise NotImplementedError, "Unknown token: #{node.type}"
-      end
-    end
-
     # Visit a ProgramNode node.
     def visit_program_node(node)
+      statements = visit(node.statements)
       bounds(node.location)
-      on_program(visit(node.statements))
+      on_program(statements)
     end
 
     ############################################################################
@@ -166,10 +180,8 @@ module Prism
     # This method could be drastically improved with some caching on the start
     # of every line, but for now it's good enough.
     def bounds(location)
-      start_offset = location.start_offset
-
-      @lineno = source[0..start_offset].count("\n") + 1
-      @column = start_offset - (source.rindex("\n", start_offset) || 0)
+      @lineno = location.start_line
+      @column = location.start_column
     end
 
     # Lazily initialize the parse result.
@@ -185,6 +197,9 @@ module Prism
     def _dispatch5(_, _, _, _, _); end # :nodoc:
     def _dispatch7(_, _, _, _, _, _, _); end # :nodoc:
 
+    alias_method :on_parse_error, :_dispatch1
+    alias_method :on_magic_comment, :_dispatch2
+
     (Ripper::SCANNER_EVENT_TABLE.merge(Ripper::PARSER_EVENT_TABLE)).each do |event, arity|
       alias_method :"on_#{event}", :"_dispatch#{arity}"
     end