prism 0.24.0 → 0.25.0

data/lib/prism/node_ext.rb

@@ -49,21 +49,39 @@ module Prism
 
   class StringNode < Node
     include HeredocQuery
+
+    # Occasionally it's helpful to treat a string as if it were interpolated so
+    # that there's a consistent interface for working with strings.
+    def to_interpolated
+      InterpolatedStringNode.new(
+        source,
+        frozen? ? InterpolatedStringNodeFlags::FROZEN : 0,
+        opening_loc,
+        [copy(opening_loc: nil, closing_loc: nil, location: content_loc)],
+        closing_loc,
+        location
+      )
+    end
   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
-      Float(slice)
+    # Occasionally it's helpful to treat a string as if it were interpolated so
+    # that there's a consistent interface for working with strings.
+    def to_interpolated
+      InterpolatedXStringNode.new(
+        source,
+        opening_loc,
+        [StringNode.new(source, 0, nil, content_loc, nil, unescaped, content_loc)],
+        closing_loc,
+        location
+      )
     end
   end
 
+  private_constant :HeredocQuery
+
   class ImaginaryNode < Node
     # Returns the value of the node as a Ruby Complex.
     def value
@@ -71,13 +89,6 @@ module Prism
     end
   end
 
-  class IntegerNode < Node
-    # Returns the value of the node as a Ruby Integer.
-    def value
-      Integer(slice)
-    end
-  end
-
   class RationalNode < Node
     # Returns the value of the node as a Ruby Rational.
     def value
@@ -98,6 +109,19 @@ module Prism
     end
   end
 
+  class ConstantWriteNode < Node
+    # Returns the list of parts for the full name of this constant.
+    # For example: [:Foo]
+    def full_name_parts
+      [name]
+    end
+
+    # Returns the full name of this constant. For example: "Foo"
+    def full_name
+      name.to_s
+    end
+  end
+
   class ConstantPathNode < Node
     # An error class raised when dynamic parts are found while computing a
     # constant path's full name. For example:
@@ -107,14 +131,23 @@ module Prism
     # local variable
     class DynamicPartsInConstantPathError < StandardError; end
 
+    # An error class raised when missing nodes are found while computing a
+    # constant path's full name. For example:
+    # Foo:: -> raises because the constant path is missing the last part
+    class MissingNodesInConstantPathError < 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
+      parts = [] #: Array[Symbol]
+      current = self #: node?
 
       while current.is_a?(ConstantPathNode)
-        parts.unshift(current.child.name)
+        child = current.child
+        if child.is_a?(MissingNode)
+          raise MissingNodesInConstantPathError, "Constant path contains missing nodes. Cannot compute full name"
+        end
+        parts.unshift(child.name)
         current = current.parent
       end
 
@@ -135,14 +168,19 @@ module Prism
     # Returns the list of parts for the full name of this constant path.
     # For example: [:Foo, :Bar]
     def full_name_parts
-      parts = case parent
-      when ConstantPathNode, ConstantReadNode
-        parent.full_name_parts
-      when nil
-        [:""]
-      else
-        raise ConstantPathNode::DynamicPartsInConstantPathError,
-          "Constant path target contains dynamic parts. Cannot compute full name"
+      parts =
+        case parent
+        when ConstantPathNode, ConstantReadNode
+          parent.full_name_parts
+        when nil
+          [:""]
+        else
+          # e.g. self::Foo, (var)::Bar = baz
+          raise ConstantPathNode::DynamicPartsInConstantPathError, "Constant target path contains dynamic parts. Cannot compute full name"
+        end
+
+      if child.is_a?(MissingNode)
+        raise ConstantPathNode::MissingNodesInConstantPathError, "Constant target path contains missing nodes. Cannot compute full name"
       end
 
       parts.push(child.name)
@@ -170,22 +208,32 @@ module Prism
   class ParametersNode < Node
     # Mirrors the Method#parameters method.
     def signature
-      names = []
+      names = [] #: Array[[Symbol, Symbol] | [Symbol]]
 
       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
+
+      if rest && rest.is_a?(RestParameterNode)
+        names << [:rest, rest.name || :*]
+      end
 
       posts.each do |param|
-        names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name])
+        if param.is_a?(MultiTargetNode)
+          names << [:req]
+        elsif param.is_a?(NoKeywordsParameterNode)
+          # Invalid syntax, e.g. "def f(**nil, ...)" moves the NoKeywordsParameterNode to posts
+          raise "Invalid syntax"
+        else
+          names << [:req, param.name]
+        end
       end
 
       # Regardless of the order in which the keywords were defined, the required
       # keywords always come first followed by the optional keywords.
-      keyopt = []
+      keyopt = [] #: Array[OptionalKeywordParameterNode]
       keywords.each do |param|
         if param.is_a?(OptionalKeywordParameterNode)
           keyopt << param

data/lib/prism/pack.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 module Prism
   # A parser for the pack template language.
@@ -148,6 +149,8 @@ module Prism
             end
           when LENGTH_MAX
             base + ", as many as possible"
+          else
+            raise
           end
         when UTF8
           "UTF-8 character"
@@ -214,6 +217,7 @@ module Prism
           else
             source = directive.source
           end
+          # @type var source_width: Integer
           "  #{source.ljust(source_width)}  #{directive.describe}"
         end
 

data/lib/prism/parse_result/comments.rb

@@ -27,11 +27,11 @@ module Prism
         end
 
         def start_offset
-          node.location.start_offset
+          node.start_offset
         end
 
         def end_offset
-          node.location.end_offset
+          node.end_offset
         end
 
         def encloses?(comment)
@@ -39,8 +39,12 @@ module Prism
             comment.location.end_offset <= end_offset
         end
 
-        def <<(comment)
-          node.location.comments << comment
+        def leading_comment(comment)
+          node.location.leading_comment(comment)
+        end
+
+        def trailing_comment(comment)
+          node.location.trailing_comment(comment)
         end
       end
 
@@ -65,8 +69,12 @@ module Prism
           false
         end
 
-        def <<(comment)
-          location.comments << comment
+        def leading_comment(comment)
+          location.leading_comment(comment)
+        end
+
+        def trailing_comment(comment)
+          location.trailing_comment(comment)
         end
       end
 
@@ -84,15 +92,23 @@ module Prism
       def attach!
         parse_result.comments.each do |comment|
           preceding, enclosing, following = nearest_targets(parse_result.value, comment)
-          target =
-            if comment.trailing?
-              preceding || following || enclosing || NodeTarget.new(parse_result.value)
+
+          if comment.trailing?
+            if preceding
+              preceding.trailing_comment(comment)
             else
-              # If a comment exists on its own line, prefer a leading comment.
-              following || preceding || enclosing || NodeTarget.new(parse_result.value)
+              (following || enclosing || NodeTarget.new(parse_result.value)).leading_comment(comment)
             end
-
-          target << comment
+          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
 
@@ -104,7 +120,7 @@ module Prism
         comment_start = comment.location.start_offset
         comment_end = comment.location.end_offset
 
-        targets = []
+        targets = [] #: Array[_Target]
         node.comment_targets.map do |value|
           case value
           when StatementsNode
@@ -117,8 +133,8 @@ module Prism
         end
 
         targets.sort_by!(&:start_offset)
-        preceding = nil
-        following = nil
+        preceding = nil #: _Target?
+        following = nil #: _Target?
 
         left = 0
         right = targets.length
@@ -134,6 +150,7 @@ module Prism
           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)
@@ -171,7 +188,7 @@ module Prism
 
     # Attach the list of comments to their respective locations in the tree.
     def attach_comments!
-      Comments.new(self).attach!
+      Comments.new(self).attach! # steep:ignore
     end
   end
 end

data/lib/prism/parse_result/newlines.rb

@@ -58,7 +58,9 @@ module Prism
 
     # Walk the tree and mark nodes that are on a new line.
     def mark_newlines!
-      value.accept(Newlines.new(Array.new(1 + source.offsets.size, false)))
+      value = self.value
+      raise "This method should only be called on a parse result that contains a node" unless Node === value
+      value.accept(Newlines.new(Array.new(1 + source.offsets.size, false))) # steep:ignore
     end
   end
 end

data/lib/prism/parse_result.rb

@@ -21,10 +21,16 @@ module Prism
       @offsets = offsets # set after parsing is done
     end
 
+    # Returns the encoding of the source code, which is set by parameters to the
+    # parser or by the encoding magic comment.
+    def encoding
+      source.encoding
+    end
+
     # Perform a byteslice on the source code using the given byte offset and
     # byte length.
     def slice(byte_offset, length)
-      source.byteslice(byte_offset, length)
+      source.byteslice(byte_offset, length) or raise
     end
 
     # Binary search through the offsets to find the line number for the given
@@ -46,7 +52,7 @@ module Prism
 
     # Return the character offset for the given byte offset.
     def character_offset(byte_offset)
-      source.byteslice(0, byte_offset).length
+      (source.byteslice(0, byte_offset) or raise).length
     end
 
     # Return the column number in characters for the given byte offset.
@@ -61,7 +67,7 @@ module Prism
     # concept of code units that differs from the number of characters in other
     # encodings, it is not captured here.
     def code_units_offset(byte_offset, encoding)
-      byteslice = source.byteslice(0, byte_offset).encode(encoding)
+      byteslice = (source.byteslice(0, byte_offset) or raise).encode(encoding)
       (encoding == Encoding::UTF_16LE || encoding == Encoding::UTF_16BE) ? (byteslice.bytesize / 2) : byteslice.length
     end
 
@@ -81,9 +87,9 @@ module Prism
 
       while left <= right
         mid = left + (right - left) / 2
-        return mid if offsets[mid] == byte_offset
+        return mid if (offset = offsets[mid]) == byte_offset
 
-        if offsets[mid] < byte_offset
+        if offset < byte_offset
           left = mid + 1
         else
           right = mid - 1
@@ -108,25 +114,51 @@ module Prism
     # The length of this location in bytes.
     attr_reader :length
 
-    # The list of comments attached to this location
-    attr_reader :comments
-
     # Create a new location object with the given source, start byte offset, and
     # byte length.
     def initialize(source, start_offset, length)
       @source = source
       @start_offset = start_offset
       @length = length
-      @comments = []
+
+      # These are used to store comments that are associated with this location.
+      # They are initialized to `nil` to save on memory when there are no
+      # comments to be attached and/or the comment-related APIs are not used.
+      @leading_comments = nil
+      @trailing_comments = nil
+    end
+
+    # These are the comments that are associated with this location that exist
+    # before the start of this location.
+    def leading_comments
+      @leading_comments ||= []
+    end
+
+    # Attach a comment to the leading comments of this location.
+    def leading_comment(comment)
+      leading_comments << comment
+    end
+
+    # These are the comments that are associated with this location that exist
+    # after the end of this location.
+    def trailing_comments
+      @trailing_comments ||= []
+    end
+
+    # Attach a comment to the trailing comments of this location.
+    def trailing_comment(comment)
+      trailing_comments << comment
+    end
+
+    # Returns all comments that are associated with this location (both leading
+    # and trailing comments).
+    def comments
+      [*@leading_comments, *@trailing_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 }
-      )
+    def copy(source: self.source, start_offset: self.start_offset, length: self.length)
+      Location.new(source, start_offset, length)
     end
 
     # Returns a string representation of this location.
@@ -230,7 +262,7 @@ module Prism
 
     # Returns true if the given other location is equal to this location.
     def ==(other)
-      other.is_a?(Location) &&
+      Location === other &&
         other.start_offset == start_offset &&
         other.end_offset == end_offset
     end
@@ -244,13 +276,6 @@ module Prism
 
       Location.new(source, start_offset, other.end_offset - start_offset)
     end
-
-    # Returns a null location that does not correspond to a source and points to
-    # the beginning of the file. Useful for when you want a location object but
-    # do not care where it points.
-    def self.null
-      new(nil, 0, 0)
-    end
   end
 
   # This represents a comment that was encountered during parsing. It is the
@@ -268,6 +293,11 @@ module Prism
     def deconstruct_keys(keys)
       { location: location }
     end
+
+    # Returns the content of the comment by slicing it from the source code.
+    def slice
+      location.slice
+    end
   end
 
   # InlineComment objects are the most common. They correspond to comments in
@@ -336,6 +366,10 @@ module Prism
 
   # This represents an error that was encountered during parsing.
   class ParseError
+    # The type of error. This is an _internal_ symbol that is used for
+    # communicating with translation layers. It is not meant to be public API.
+    attr_reader :type
+
     # The message associated with this error.
     attr_reader :message
 
@@ -346,7 +380,8 @@ module Prism
     attr_reader :level
 
     # Create a new error object with the given message and location.
-    def initialize(message, location, level)
+    def initialize(type, message, location, level)
+      @type = type
       @message = message
       @location = location
       @level = level
@@ -354,17 +389,21 @@ module Prism
 
     # Implement the hash pattern matching interface for ParseError.
     def deconstruct_keys(keys)
-      { message: message, location: location, level: level }
+      { type: type, message: message, location: location, level: level }
     end
 
     # Returns a string representation of this error.
     def inspect
-      "#<Prism::ParseError @message=#{@message.inspect} @location=#{@location.inspect} @level=#{@level.inspect}>"
+      "#<Prism::ParseError @type=#{@type.inspect} @message=#{@message.inspect} @location=#{@location.inspect} @level=#{@level.inspect}>"
     end
   end
 
   # This represents a warning that was encountered during parsing.
   class ParseWarning
+    # The type of warning. This is an _internal_ symbol that is used for
+    # communicating with translation layers. It is not meant to be public API.
+    attr_reader :type
+
     # The message associated with this warning.
     attr_reader :message
 
@@ -375,7 +414,8 @@ module Prism
     attr_reader :level
 
     # Create a new warning object with the given message and location.
-    def initialize(message, location, level)
+    def initialize(type, message, location, level)
+      @type = type
       @message = message
       @location = location
       @level = level
@@ -383,12 +423,12 @@ module Prism
 
     # Implement the hash pattern matching interface for ParseWarning.
     def deconstruct_keys(keys)
-      { message: message, location: location, level: level }
+      { type: type, message: message, location: location, level: level }
     end
 
     # Returns a string representation of this warning.
     def inspect
-      "#<Prism::ParseWarning @message=#{@message.inspect} @location=#{@location.inspect} @level=#{@level.inspect}>"
+      "#<Prism::ParseWarning @type=#{@type.inspect} @message=#{@message.inspect} @location=#{@location.inspect} @level=#{@level.inspect}>"
     end
   end
 
@@ -437,6 +477,11 @@ module Prism
       { value: value, comments: comments, magic_comments: magic_comments, data_loc: data_loc, errors: errors, warnings: warnings }
     end
 
+    # Returns the encoding of the source code that was parsed.
+    def encoding
+      source.encoding
+    end
+
     # Returns true if there were no errors during parsing and false if there
     # were.
     def success?
@@ -477,8 +522,9 @@ module Prism
 
     # A Location object representing the location of this token in the source.
     def location
-      return @location if @location.is_a?(Location)
-      @location = Location.new(source, @location >> 32, @location & 0xFFFFFFFF)
+      location = @location
+      return location if location.is_a?(Location)
+      @location = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
     # Implement the pretty print interface for Token.
@@ -498,7 +544,7 @@ module Prism
 
     # Returns true if the given other token is equal to this token.
     def ==(other)
-      other.is_a?(Token) &&
+      Token === other &&
         other.type == type &&
         other.value == value
     end

data/lib/prism/pattern.rb

@@ -69,7 +69,14 @@ module Prism
     # nodes.
     def compile
       result = Prism.parse("case nil\nin #{query}\nend")
-      compile_node(result.value.statements.body.last.conditions.last.pattern)
+
+      case_match_node = result.value.statements.body.last
+      raise CompilationError, case_match_node.inspect unless case_match_node.is_a?(CaseMatchNode)
+
+      in_node = case_match_node.conditions.last
+      raise CompilationError, in_node.inspect unless in_node.is_a?(InNode)
+
+      compile_node(in_node.pattern)
     end
 
     # Scan the given node and all of its children for nodes that match the
@@ -77,13 +84,13 @@ module Prism
     # matches the pattern. If no block is given, an enumerator will be returned
     # that will yield each node that matches the pattern.
     def scan(root)
-      return to_enum(__method__, root) unless block_given?
+      return to_enum(:scan, root) unless block_given?
 
       @compiled ||= compile
       queue = [root]
 
       while (node = queue.shift)
-        yield node if @compiled.call(node)
+        yield node if @compiled.call(node) # steep:ignore
         queue.concat(node.compact_child_nodes)
       end
     end
@@ -174,7 +181,12 @@ module Prism
 
       preprocessed =
         node.elements.to_h do |element|
-          [element.key.unescaped.to_sym, compile_node(element.value)]
+          key = element.key
+          if key.is_a?(SymbolNode)
+            [key.unescaped.to_sym, compile_node(element.value)]
+          else
+            raise CompilationError, element.inspect
+          end
         end
 
       compiled_keywords = ->(other) do

data/lib/prism/polyfill/string.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Polyfill for String#unpack1 with the offset parameter.
+if String.instance_method(:unpack1).parameters.none? { |_, name| name == :offset }
+  String.prepend(
+    Module.new {
+      def unpack1(format, offset: 0) # :nodoc:
+        offset == 0 ? super(format) : self[offset..].unpack1(format) # steep:ignore
+      end
+    }
+  )
+end