prism 0.15.1 → 0.16.0

data/lib/prism/node.rb

@@ -462,9 +462,13 @@ module Prism
     # attr_reader arguments: Array[Node]
     attr_reader :arguments
 
-    # def initialize: (arguments: Array[Node], location: Location) -> void
-    def initialize(arguments, location)
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
+    # def initialize: (arguments: Array[Node], flags: Integer, location: Location) -> void
+    def initialize(arguments, flags, location)
       @arguments = arguments
+      @flags = flags
       @location = location
     end
 
@@ -492,6 +496,7 @@ module Prism
     def copy(**params)
       ArgumentsNode.new(
         params.fetch(:arguments) { arguments },
+        params.fetch(:flags) { flags },
         params.fetch(:location) { location },
       )
     end
@@ -501,12 +506,19 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { arguments: arguments, location: location }
+      { arguments: arguments, flags: flags, location: location }
+    end
+
+    # def keyword_splat?: () -> bool
+    def keyword_splat?
+      flags.anybits?(ArgumentsNodeFlags::KEYWORD_SPLAT)
     end
 
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "└── arguments: #{inspector.list("#{inspector.prefix}    ", arguments)}"
+      inspector << "├── arguments: #{inspector.list("#{inspector.prefix}│   ", arguments)}"
+      flags = [("keyword_splat" if keyword_splat?)].compact
+      inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector.to_str
     end
 
@@ -1642,7 +1654,11 @@ module Prism
 
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
+      if (name = self.name).nil?
+        inspector << "├── name: ∅\n"
+      else
+        inspector << "├── name: #{name.inspect}\n"
+      end
       inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
       inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector.to_str
@@ -7166,11 +7182,11 @@ module Prism
     # attr_reader constant: Node?
     attr_reader :constant
 
-    # attr_reader assocs: Array[Node]
-    attr_reader :assocs
+    # attr_reader elements: Array[Node]
+    attr_reader :elements
 
-    # attr_reader kwrest: Node?
-    attr_reader :kwrest
+    # attr_reader rest: Node?
+    attr_reader :rest
 
     # attr_reader opening_loc: Location?
     attr_reader :opening_loc
@@ -7178,11 +7194,11 @@ module Prism
     # attr_reader closing_loc: Location?
     attr_reader :closing_loc
 
-    # def initialize: (constant: Node?, assocs: Array[Node], kwrest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
-    def initialize(constant, assocs, kwrest, opening_loc, closing_loc, location)
+    # def initialize: (constant: Node?, elements: Array[Node], rest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+    def initialize(constant, elements, rest, opening_loc, closing_loc, location)
       @constant = constant
-      @assocs = assocs
-      @kwrest = kwrest
+      @elements = elements
+      @rest = rest
       @opening_loc = opening_loc
       @closing_loc = closing_loc
       @location = location
@@ -7195,29 +7211,29 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [constant, *assocs, kwrest]
+      [constant, *elements, rest]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = []
       compact << constant if constant
-      compact.concat(assocs)
-      compact << kwrest if kwrest
+      compact.concat(elements)
+      compact << rest if rest
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*constant, *assocs, *kwrest, *opening_loc, *closing_loc]
+      [*constant, *elements, *rest, *opening_loc, *closing_loc]
     end
 
     # def copy: (**params) -> HashPatternNode
     def copy(**params)
       HashPatternNode.new(
         params.fetch(:constant) { constant },
-        params.fetch(:assocs) { assocs },
-        params.fetch(:kwrest) { kwrest },
+        params.fetch(:elements) { elements },
+        params.fetch(:rest) { rest },
         params.fetch(:opening_loc) { opening_loc },
         params.fetch(:closing_loc) { closing_loc },
         params.fetch(:location) { location },
@@ -7229,7 +7245,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { constant: constant, assocs: assocs, kwrest: kwrest, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
+      { constant: constant, elements: elements, rest: rest, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
     end
 
     # def opening: () -> String?
@@ -7250,12 +7266,12 @@ module Prism
         inspector << "├── constant:\n"
         inspector << constant.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
       end
-      inspector << "├── assocs: #{inspector.list("#{inspector.prefix}│   ", assocs)}"
-      if (kwrest = self.kwrest).nil?
-        inspector << "├── kwrest: ∅\n"
+      inspector << "├── elements: #{inspector.list("#{inspector.prefix}│   ", elements)}"
+      if (rest = self.rest).nil?
+        inspector << "├── rest: ∅\n"
       else
-        inspector << "├── kwrest:\n"
-        inspector << kwrest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+        inspector << "├── rest:\n"
+        inspector << rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
       end
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
@@ -9917,7 +9933,11 @@ module Prism
 
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
+      if (name = self.name).nil?
+        inspector << "├── name: ∅\n"
+      else
+        inspector << "├── name: #{name.inspect}\n"
+      end
       inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
       inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector.to_str
@@ -11421,11 +11441,17 @@ module Prism
 
   # Represents a multi-target expression.
   #
-  #     a, b, c = 1, 2, 3
-  #     ^^^^^^^
+  #     a, (b, c) = 1, 2, 3
+  #        ^^^^^^
   class MultiTargetNode < Node
-    # attr_reader targets: Array[Node]
-    attr_reader :targets
+    # attr_reader lefts: Array[Node]
+    attr_reader :lefts
+
+    # attr_reader rest: Node?
+    attr_reader :rest
+
+    # attr_reader rights: Array[Node]
+    attr_reader :rights
 
     # attr_reader lparen_loc: Location?
     attr_reader :lparen_loc
@@ -11433,9 +11459,11 @@ module Prism
     # attr_reader rparen_loc: Location?
     attr_reader :rparen_loc
 
-    # def initialize: (targets: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location) -> void
-    def initialize(targets, lparen_loc, rparen_loc, location)
-      @targets = targets
+    # def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location) -> void
+    def initialize(lefts, rest, rights, lparen_loc, rparen_loc, location)
+      @lefts = lefts
+      @rest = rest
+      @rights = rights
       @lparen_loc = lparen_loc
       @rparen_loc = rparen_loc
       @location = location
@@ -11448,23 +11476,29 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [*targets]
+      [*lefts, rest, *rights]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
-      [*targets]
+      compact = []
+      compact.concat(lefts)
+      compact << rest if rest
+      compact.concat(rights)
+      compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*targets, *lparen_loc, *rparen_loc]
+      [*lefts, *rest, *rights, *lparen_loc, *rparen_loc]
     end
 
     # def copy: (**params) -> MultiTargetNode
     def copy(**params)
       MultiTargetNode.new(
-        params.fetch(:targets) { targets },
+        params.fetch(:lefts) { lefts },
+        params.fetch(:rest) { rest },
+        params.fetch(:rights) { rights },
         params.fetch(:lparen_loc) { lparen_loc },
         params.fetch(:rparen_loc) { rparen_loc },
         params.fetch(:location) { location },
@@ -11476,7 +11510,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { targets: targets, lparen_loc: lparen_loc, rparen_loc: rparen_loc, location: location }
+      { lefts: lefts, rest: rest, rights: rights, lparen_loc: lparen_loc, rparen_loc: rparen_loc, location: location }
     end
 
     # def lparen: () -> String?
@@ -11491,7 +11525,14 @@ module Prism
 
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── targets: #{inspector.list("#{inspector.prefix}│   ", targets)}"
+      inspector << "├── lefts: #{inspector.list("#{inspector.prefix}│   ", lefts)}"
+      if (rest = self.rest).nil?
+        inspector << "├── rest: ∅\n"
+      else
+        inspector << "├── rest:\n"
+        inspector << rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── rights: #{inspector.list("#{inspector.prefix}│   ", rights)}"
       inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
       inspector << "└── rparen_loc: #{inspector.location(rparen_loc)}\n"
       inspector.to_str
@@ -11531,8 +11572,14 @@ module Prism
   #     a, b, c = 1, 2, 3
   #     ^^^^^^^^^^^^^^^^^
   class MultiWriteNode < Node
-    # attr_reader targets: Array[Node]
-    attr_reader :targets
+    # attr_reader lefts: Array[Node]
+    attr_reader :lefts
+
+    # attr_reader rest: Node?
+    attr_reader :rest
+
+    # attr_reader rights: Array[Node]
+    attr_reader :rights
 
     # attr_reader lparen_loc: Location?
     attr_reader :lparen_loc
@@ -11546,9 +11593,11 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (targets: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(targets, lparen_loc, rparen_loc, operator_loc, value, location)
-      @targets = targets
+    # def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location)
+      @lefts = lefts
+      @rest = rest
+      @rights = rights
       @lparen_loc = lparen_loc
       @rparen_loc = rparen_loc
       @operator_loc = operator_loc
@@ -11563,23 +11612,30 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [*targets, value]
+      [*lefts, rest, *rights, value]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
-      [*targets, value]
+      compact = []
+      compact.concat(lefts)
+      compact << rest if rest
+      compact.concat(rights)
+      compact << value
+      compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*targets, *lparen_loc, *rparen_loc, operator_loc, value]
+      [*lefts, *rest, *rights, *lparen_loc, *rparen_loc, operator_loc, value]
     end
 
     # def copy: (**params) -> MultiWriteNode
     def copy(**params)
       MultiWriteNode.new(
-        params.fetch(:targets) { targets },
+        params.fetch(:lefts) { lefts },
+        params.fetch(:rest) { rest },
+        params.fetch(:rights) { rights },
         params.fetch(:lparen_loc) { lparen_loc },
         params.fetch(:rparen_loc) { rparen_loc },
         params.fetch(:operator_loc) { operator_loc },
@@ -11593,7 +11649,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { targets: targets, lparen_loc: lparen_loc, rparen_loc: rparen_loc, operator_loc: operator_loc, value: value, location: location }
+      { lefts: lefts, rest: rest, rights: rights, lparen_loc: lparen_loc, rparen_loc: rparen_loc, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def lparen: () -> String?
@@ -11613,7 +11669,14 @@ module Prism
 
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── targets: #{inspector.list("#{inspector.prefix}│   ", targets)}"
+      inspector << "├── lefts: #{inspector.list("#{inspector.prefix}│   ", lefts)}"
+      if (rest = self.rest).nil?
+        inspector << "├── rest: ∅\n"
+      else
+        inspector << "├── rest:\n"
+        inspector << rest.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── rights: #{inspector.list("#{inspector.prefix}│   ", rights)}"
       inspector << "├── lparen_loc: #{inspector.location(lparen_loc)}\n"
       inspector << "├── rparen_loc: #{inspector.location(rparen_loc)}\n"
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
@@ -13514,114 +13577,6 @@ module Prism
     end
   end
 
-  # Represents a destructured required parameter node.
-  #
-  #     def foo((bar, baz))
-  #             ^^^^^^^^^^
-  #     end
-  class RequiredDestructuredParameterNode < Node
-    # attr_reader parameters: Array[Node]
-    attr_reader :parameters
-
-    # attr_reader opening_loc: Location
-    attr_reader :opening_loc
-
-    # attr_reader closing_loc: Location
-    attr_reader :closing_loc
-
-    # def initialize: (parameters: Array[Node], opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def initialize(parameters, opening_loc, closing_loc, location)
-      @parameters = parameters
-      @opening_loc = opening_loc
-      @closing_loc = closing_loc
-      @location = location
-    end
-
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_required_destructured_parameter_node(self)
-    end
-
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [*parameters]
-    end
-
-    # def compact_child_nodes: () -> Array[Node]
-    def compact_child_nodes
-      [*parameters]
-    end
-
-    # def comment_targets: () -> Array[Node | Location]
-    def comment_targets
-      [*parameters, opening_loc, closing_loc]
-    end
-
-    # def copy: (**params) -> RequiredDestructuredParameterNode
-    def copy(**params)
-      RequiredDestructuredParameterNode.new(
-        params.fetch(:parameters) { parameters },
-        params.fetch(:opening_loc) { opening_loc },
-        params.fetch(:closing_loc) { closing_loc },
-        params.fetch(:location) { location },
-      )
-    end
-
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { parameters: parameters, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
-    end
-
-    # def opening: () -> String
-    def opening
-      opening_loc.slice
-    end
-
-    # def closing: () -> String
-    def closing
-      closing_loc.slice
-    end
-
-    def inspect(inspector = NodeInspector.new)
-      inspector << inspector.header(self)
-      inspector << "├── parameters: #{inspector.list("#{inspector.prefix}│   ", parameters)}"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      inspector << "└── closing_loc: #{inspector.location(closing_loc)}\n"
-      inspector.to_str
-    end
-
-    # Sometimes you want to check an instance of a node against a list of
-    # classes to see what kind of behavior to perform. Usually this is done by
-    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-    # case statement and doing `case node; when cls1; when cls2; end`. Both of
-    # these approaches are relatively slow because of the constant lookups,
-    # method calls, and/or array allocations.
-    #
-    # Instead, you can call #type, which will return to you a symbol that you
-    # can use for comparison. This is faster than the other approaches because
-    # it uses a single integer comparison, but also because if you're on CRuby
-    # you can take advantage of the fact that case statements with all symbol
-    # keys will use a jump table.
-    #
-    # def type: () -> Symbol
-    def type
-      :required_destructured_parameter_node
-    end
-
-    # Similar to #type, this method returns a symbol that you can use for
-    # splitting on the type of the node without having to do a long === chain.
-    # Note that like #type, it will still be slower than using == for a single
-    # class, but should be faster in a case statement or an array comparison.
-    #
-    # def self.type: () -> Symbol
-    def self.type
-      :required_destructured_parameter_node
-    end
-  end
-
   # Represents a required parameter to a method, block, or lambda definition.
   #
   #     def a(b)
@@ -14035,7 +13990,11 @@ module Prism
 
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
+      if (name = self.name).nil?
+        inspector << "├── name: ∅\n"
+      else
+        inspector << "├── name: #{name.inspect}\n"
+      end
       inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
       inspector << "└── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector.to_str
@@ -16345,6 +16304,11 @@ module Prism
     end
   end
 
+  module ArgumentsNodeFlags
+    # if arguments contain keyword splat
+    KEYWORD_SPLAT = 1 << 0
+  end
+
   module CallNodeFlags
     # &. operator
     SAFE_NAVIGATION = 1 << 0

data/lib/prism/node_ext.rb

@@ -3,6 +3,19 @@
 # Here we are reopening the prism module to provide methods on nodes that aren't
 # templated and are meant as convenience methods.
 module Prism
+  module RegularExpressionOptions
+    # 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
+
+  private_constant :RegularExpressionOptions
+
   class FloatNode < Node
     # Returns the value of the node as a Ruby Float.
     def value
@@ -24,15 +37,16 @@ module Prism
     end
   end
 
+  class InterpolatedMatchLastLineNode < Node
+    include RegularExpressionOptions
+  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
+    include RegularExpressionOptions
+  end
+
+  class MatchLastLineNode < Node
+    include RegularExpressionOptions
   end
 
   class RationalNode < Node
@@ -43,14 +57,7 @@ module Prism
   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
+    include RegularExpressionOptions
   end
 
   class ConstantReadNode < Node

data/lib/prism/parse_result.rb

@@ -16,16 +16,32 @@ module Prism
       source.byteslice(offset, length)
     end
 
+    # Binary search through the offsets to find the line number for the given
+    # offset.
     def line(value)
-      offsets.bsearch_index { |offset| offset > value } || offsets.length
+      left = 0
+      right = offsets.length - 1
+
+      while left <= right
+        mid = left + (right - left) / 2
+        return mid if offsets[mid] == value
+
+        if offsets[mid] < value
+          left = mid + 1
+        else
+          right = mid - 1
+        end
+      end
+
+      left - 1
     end
 
     def line_offset(value)
-      offsets[line(value) - 1]
+      offsets[line(value)]
     end
 
     def column(value)
-      value - offsets[line(value) - 1]
+      value - offsets[line(value)]
     end
 
     private
@@ -86,7 +102,7 @@ module Prism
 
     # The line number where this location starts.
     def start_line
-      source.line(start_offset)
+      source.line(start_offset) + 1
     end
 
     # The content of the line where this location starts before this location.
@@ -97,7 +113,7 @@ module Prism
 
     # The line number where this location ends.
     def end_line
-      source.line(end_offset - 1)
+      source.line(end_offset) + 1
     end
 
     # The column number in bytes where this location starts from the start of

data/lib/prism/pattern.rb

@@ -158,12 +158,12 @@ module Prism
     # in InstanceVariableReadNode[name: Symbol]
     # in { name: Symbol }
     def compile_hash_pattern_node(node)
-      compile_error(node) unless node.kwrest.nil?
+      compile_error(node) if node.rest
       compiled_constant = compile_node(node.constant) if node.constant
 
       preprocessed =
-        node.assocs.to_h do |assoc|
-          [assoc.key.unescaped.to_sym, compile_node(assoc.value)]
+        node.elements.to_h do |element|
+          [element.key.unescaped.to_sym, compile_node(element.value)]
         end
 
       compiled_keywords = ->(other) do