prism 0.28.0 → 0.29.0

data/sig/prism/node.rbs

@@ -504,13 +504,13 @@ module Prism
     attr_reader message_loc: Location?
     attr_reader read_name: Symbol
     attr_reader write_name: Symbol
-    attr_reader operator: Symbol
-    attr_reader operator_loc: Location
+    attr_reader binary_operator: Symbol
+    attr_reader binary_operator_loc: Location
     attr_reader value: Prism::node
 
-    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol operator, Location operator_loc, Prism::node value, Location location) -> void
-    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOperatorWriteNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Prism::node, location: Location }
+    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol binary_operator, Location binary_operator_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node, location: Location }
     def safe_navigation?: () -> bool
     def variable_call?: () -> bool
     def attribute_write?: () -> bool
@@ -715,13 +715,13 @@ module Prism
 
     attr_reader name: Symbol
     attr_reader name_loc: Location
-    attr_reader operator_loc: Location
+    attr_reader binary_operator_loc: Location
     attr_reader value: Prism::node
-    attr_reader operator: Symbol
+    attr_reader binary_operator: Symbol
 
-    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
-    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> ClassVariableOperatorWriteNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def initialize: (Source source, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ClassVariableOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
     def type: () -> :class_variable_operator_write_node
             | ...
     def self.type: () -> :class_variable_operator_write_node
@@ -833,13 +833,13 @@ module Prism
 
     attr_reader name: Symbol
     attr_reader name_loc: Location
-    attr_reader operator_loc: Location
+    attr_reader binary_operator_loc: Location
     attr_reader value: Prism::node
-    attr_reader operator: Symbol
+    attr_reader binary_operator: Symbol
 
-    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
-    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> ConstantOperatorWriteNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def initialize: (Source source, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ConstantOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
     def type: () -> :constant_operator_write_node
             | ...
     def self.type: () -> :constant_operator_write_node
@@ -915,13 +915,13 @@ module Prism
     include _Node
 
     attr_reader target: ConstantPathNode
-    attr_reader operator_loc: Location
+    attr_reader binary_operator_loc: Location
     attr_reader value: Prism::node
-    attr_reader operator: Symbol
+    attr_reader binary_operator: Symbol
 
-    def initialize: (Source source, ConstantPathNode target, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
-    def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> ConstantPathOperatorWriteNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def initialize: (Source source, ConstantPathNode target, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
+    def copy: (?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ConstantPathOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
     def type: () -> :constant_path_operator_write_node
             | ...
     def self.type: () -> :constant_path_operator_write_node
@@ -1387,13 +1387,13 @@ module Prism
 
     attr_reader name: Symbol
     attr_reader name_loc: Location
-    attr_reader operator_loc: Location
+    attr_reader binary_operator_loc: Location
     attr_reader value: Prism::node
-    attr_reader operator: Symbol
+    attr_reader binary_operator: Symbol
 
-    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
-    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> GlobalVariableOperatorWriteNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def initialize: (Source source, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> GlobalVariableOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
     def type: () -> :global_variable_operator_write_node
             | ...
     def self.type: () -> :global_variable_operator_write_node
@@ -1687,13 +1687,13 @@ module Prism
     attr_reader arguments: ArgumentsNode?
     attr_reader closing_loc: Location
     attr_reader block: Prism::node?
-    attr_reader operator: Symbol
-    attr_reader operator_loc: Location
+    attr_reader binary_operator: Symbol
+    attr_reader binary_operator_loc: Location
     attr_reader value: Prism::node
 
-    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Symbol operator, Location operator_loc, Prism::node value, Location location) -> void
-    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexOperatorWriteNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator: Symbol, operator_loc: Location, value: Prism::node, location: Location }
+    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Symbol binary_operator, Location binary_operator_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node, location: Location }
     def safe_navigation?: () -> bool
     def variable_call?: () -> bool
     def attribute_write?: () -> bool
@@ -1805,13 +1805,13 @@ module Prism
 
     attr_reader name: Symbol
     attr_reader name_loc: Location
-    attr_reader operator_loc: Location
+    attr_reader binary_operator_loc: Location
     attr_reader value: Prism::node
-    attr_reader operator: Symbol
+    attr_reader binary_operator: Symbol
 
-    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
-    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> InstanceVariableOperatorWriteNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def initialize: (Source source, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> InstanceVariableOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
     def type: () -> :instance_variable_operator_write_node
             | ...
     def self.type: () -> :instance_variable_operator_write_node
@@ -2160,15 +2160,15 @@ module Prism
     include _Node
 
     attr_reader name_loc: Location
-    attr_reader operator_loc: Location
+    attr_reader binary_operator_loc: Location
     attr_reader value: Prism::node
     attr_reader name: Symbol
-    attr_reader operator: Symbol
+    attr_reader binary_operator: Symbol
     attr_reader depth: Integer
 
-    def initialize: (Source source, Location name_loc, Location operator_loc, Prism::node value, Symbol name, Symbol operator, Integer depth, Location location) -> void
-    def copy: (?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?operator: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOperatorWriteNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, operator: Symbol, depth: Integer, location: Location }
+    def initialize: (Source source, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol name, Symbol binary_operator, Integer depth, Location location) -> void
+    def copy: (?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?binary_operator: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer, location: Location }
     def type: () -> :local_variable_operator_write_node
             | ...
     def self.type: () -> :local_variable_operator_write_node
@@ -2600,14 +2600,14 @@ module Prism
     attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]
     attr_reader optionals: Array[OptionalParameterNode]
     attr_reader rest: RestParameterNode | ImplicitRestNode | nil
-    attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode]
+    attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode]
     attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]
     attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil
     attr_reader block: BlockParameterNode?
 
-    def initialize: (Source source, Array[RequiredParameterNode | MultiTargetNode] requireds, Array[OptionalParameterNode] optionals, RestParameterNode | ImplicitRestNode | nil rest, Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode] posts, Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] keywords, KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil keyword_rest, BlockParameterNode? block, Location location) -> void
-    def copy: (?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?, ?location: Location) -> ParametersNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode?, location: Location }
+    def initialize: (Source source, Array[RequiredParameterNode | MultiTargetNode] requireds, Array[OptionalParameterNode] optionals, RestParameterNode | ImplicitRestNode | nil rest, Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode] posts, Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] keywords, KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil keyword_rest, BlockParameterNode? block, Location location) -> void
+    def copy: (?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?, ?location: Location) -> ParametersNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode?, location: Location }
     def type: () -> :parameters_node
             | ...
     def self.type: () -> :parameters_node

data/sig/prism/node_ext.rbs

@@ -75,4 +75,8 @@ module Prism
   class ParametersNode < Node
     def signature: () -> Array[[Symbol, Symbol] | [Symbol]]
   end
+
+  class CallNode < Node
+    def full_message_loc: () -> Location?
+  end
 end

data/src/diagnostic.c

@@ -8,7 +8,7 @@
 
 #include "prism/diagnostic.h"
 
-#define PM_DIAGNOSTIC_ID_MAX 291
+#define PM_DIAGNOSTIC_ID_MAX 301
 
 /** This struct holds the data for each diagnostic. */
 typedef struct {
@@ -99,22 +99,24 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_ARGUMENT_AFTER_BLOCK]               = { "unexpected argument after a block argument", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_AFTER_FORWARDING_ELLIPSES] = { "unexpected argument after `...`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_BARE_HASH]                 = { "unexpected bare hash argument", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ARGUMENT_BLOCK_FORWARDING]          = { "both a block argument and a forwarding argument; only one block is allowed", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_BLOCK_MULTI]               = { "both block arg and actual block given; only one block is allowed", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ARGUMENT_CONFLICT_AMPERSAND]        = { "unexpected `&`; anonymous block parameter is also used within block", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ARGUMENT_CONFLICT_STAR]             = { "unexpected `*`; anonymous rest parameter is also used within block", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ARGUMENT_CONFLICT_STAR_STAR]        = { "unexpected `**`; anonymous keyword rest parameter is also used within block", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_FORMAL_CLASS]              = { "invalid formal argument; formal argument cannot be a class variable", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_FORMAL_CONSTANT]           = { "invalid formal argument; formal argument cannot be a constant", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_FORMAL_GLOBAL]             = { "invalid formal argument; formal argument cannot be a global variable", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_FORMAL_IVAR]               = { "invalid formal argument; formal argument cannot be an instance variable", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_FORWARDING_UNBOUND]        = { "unexpected `...` in an non-parenthesized call", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_IN]                        = { "unexpected `in` keyword in arguments", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ARGUMENT_NO_FORWARDING_AMP]         = { "unexpected `&`; no anonymous block parameter", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ARGUMENT_NO_FORWARDING_AMPERSAND]   = { "unexpected `&`; no anonymous block parameter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES]    = { "unexpected ... when the parent method is not forwarding", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_NO_FORWARDING_STAR]        = { "unexpected `*`; no anonymous rest parameter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_NO_FORWARDING_STAR_STAR]   = { "unexpected `**`; no anonymous keyword rest parameter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT]   = { "unexpected `*` splat argument after a `**` keyword splat argument", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_SPLAT_AFTER_SPLAT]         = { "unexpected `*` splat argument after a `*` splat argument", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARGUMENT_TERM_PAREN]                = { "unexpected %s; expected a `)` to close the arguments", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_ARGUMENT_UNEXPECTED_BLOCK]          = { "unexpected `{` after a method call without parenthesis", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_ARGUMENT_UNEXPECTED_BLOCK]          = { "unexpected '{' after a method call without parenthesis", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARRAY_ELEMENT]                      = { "expected an element for the array", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARRAY_EXPRESSION]                   = { "expected an expression for the array element", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_ARRAY_EXPRESSION_AFTER_STAR]        = { "expected an expression after `*` in the array", PM_ERROR_LEVEL_SYNTAX },
@@ -154,7 +156,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_DEF_ENDLESS_SETTER]                 = { "invalid method name; a setter method cannot be defined in an endless method definition", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_DEF_NAME]                           = { "unexpected %s; expected a method name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_DEF_PARAMS_TERM]                    = { "expected a delimiter to close the parameters", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_DEF_PARAMS_TERM_PAREN]              = { "expected a `)` to close the parameters", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_DEF_PARAMS_TERM_PAREN]              = { "unexpected %s; expected a `)` to close the parameters", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_DEF_RECEIVER]                       = { "expected a receiver for the method definition", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_DEF_RECEIVER_TERM]                  = { "expected a `.` or `::` after the receiver in a method definition", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_DEF_TERM]                           = { "expected an `end` to close the `def` statement", PM_ERROR_LEVEL_SYNTAX },
@@ -182,11 +184,12 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL]      = { "expected an expression after `=`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_EXPRESSION_AFTER_LESS_LESS]  = { "expected an expression after `<<`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_EXPRESSION_AFTER_LPAREN]     = { "expected an expression after `(`", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR]   = { "expected an expression after the operator", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR]   = { "unexpected %s; expected an expression after the operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT]      = { "expected an expression after `*` splat in an argument", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT_HASH] = { "expected an expression after `**` in a hash", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_EXPRESSION_AFTER_STAR]       = { "expected an expression after `*`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_IDENT_REQ_PARAMETER]         = { "expected an identifier for the required parameter", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_EXPECT_IN_DELIMITER]                = { "expected a delimiter after the patterns of an `in` clause", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_LPAREN_REQ_PARAMETER]        = { "expected a `(` to start a required parameter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_MESSAGE]                     = { "unexpected %s; expecting a message to send to the receiver", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_RBRACKET]                    = { "expected a matching `]`", PM_ERROR_LEVEL_SYNTAX },
@@ -214,9 +217,9 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_HASH_KEY]                           = { "unexpected %s, expecting '}' or a key in the hash literal", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_HASH_ROCKET]                        = { "expected a `=>` between the hash key and value", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_HASH_TERM]                          = { "expected a `}` to close the hash literal", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_HASH_VALUE]                         = { "expected a value in the hash literal", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_HASH_VALUE]                         = { "unexpected %s; expected a value in the hash literal", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_HEREDOC_IDENTIFIER]                 = { "unterminated here document identifier", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_HEREDOC_TERM]                       = { "unterminated heredoc; can't find string \"%.*s\"", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_HEREDOC_TERM]                       = { "unterminated heredoc; can't find string \"%.*s\" anywhere before EOF", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INCOMPLETE_QUESTION_MARK]           = { "incomplete expression at `?`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3]      = { "`%.*s' is not allowed as a class variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INCOMPLETE_VARIABLE_CLASS]          = { "'%.*s' is not allowed as a class variable name", PM_ERROR_LEVEL_SYNTAX },
@@ -224,11 +227,13 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_INCOMPLETE_VARIABLE_INSTANCE]       = { "'%.*s' is not allowed as an instance variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INSTANCE_VARIABLE_BARE]             = { "'@' without identifiers is not allowed as an instance variable name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_BLOCK_EXIT]                 = { "Invalid %s", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_ESCAPE_CHARACTER]           = { "Invalid escape character syntax", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_FLOAT_EXPONENT]             = { "invalid exponent", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_LOCAL_VARIABLE_READ]        = { "identifier %.*s is not valid to get", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_LOCAL_VARIABLE_WRITE]       = { "identifier %.*s is not valid to set", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_NUMBER_BINARY]              = { "invalid binary number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_NUMBER_DECIMAL]             = { "invalid decimal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_INVALID_NUMBER_FRACTION]            = { "unexpected fraction part after numeric literal", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_NUMBER_HEXADECIMAL]         = { "invalid hexadecimal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_NUMBER_OCTAL]               = { "invalid octal number; numeric literal without digits", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER]    = { "invalid underscore placement in number", PM_ERROR_LEVEL_SYNTAX },
@@ -278,6 +283,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_PARAMETER_ASSOC_SPLAT_MULTI]        = { "unexpected multiple `**` splat parameters", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PARAMETER_BLOCK_MULTI]              = { "multiple block parameters; only one block is allowed", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PARAMETER_CIRCULAR]                 = { "circular argument reference - %.*s", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_PARAMETER_FORWARDING_AFTER_REST]    = { "... after rest argument", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PARAMETER_METHOD_NAME]              = { "unexpected name for a parameter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PARAMETER_NAME_DUPLICATED]          = { "duplicated argument name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PARAMETER_NO_DEFAULT]               = { "expected a default value for the parameter", PM_ERROR_LEVEL_SYNTAX },
@@ -300,9 +306,11 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_PATTERN_EXPRESSION_AFTER_PIPE]      = { "expected a pattern expression after the `|` operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE]     = { "expected a pattern expression after the range operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_EXPRESSION_AFTER_REST]      = { "unexpected pattern expression after the `**` expression", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_PATTERN_HASH_KEY]                   = { "expected a key in the hash pattern", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_PATTERN_HASH_IMPLICIT]              = { "unexpected implicit hash in pattern; use '{' to delineate", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_PATTERN_HASH_KEY]                   = { "unexpected %s; expected a key in the hash pattern", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_HASH_KEY_DUPLICATE]         = { "duplicated key name", PM_ERROR_LEVEL_SYNTAX },
-    [PM_ERR_PATTERN_HASH_KEY_LABEL]             = { "expected a label as the key in the hash pattern", PM_ERROR_LEVEL_SYNTAX }, // TODO // THIS // AND // ABOVE // IS WEIRD
+    [PM_ERR_PATTERN_HASH_KEY_INTERPOLATED]      = { "symbol literal with interpolation is not allowed", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_PATTERN_HASH_KEY_LABEL]             = { "expected a label as the key in the hash pattern", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_HASH_KEY_LOCALS]            = { "key must be valid as local variables", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_IDENT_AFTER_HROCKET]        = { "expected an identifier after the `=>` operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_LABEL_AFTER_COMMA]          = { "expected a label after the `,` in the hash pattern", PM_ERROR_LEVEL_SYNTAX },
@@ -377,6 +385,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_WARN_KEYWORD_EOL]                       = { "`%.*s` at the end of line without an expression", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_LITERAL_IN_CONDITION_DEFAULT]      = { "%sliteral in %s", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_LITERAL_IN_CONDITION_VERBOSE]      = { "%sliteral in %s", PM_WARNING_LEVEL_VERBOSE },
+    [PM_WARN_SHAREABLE_CONSTANT_VALUE_LINE]     = { "'shareable_constant_value' is ignored unless in comment-only line", PM_WARNING_LEVEL_VERBOSE },
     [PM_WARN_SHEBANG_CARRIAGE_RETURN]           = { "shebang line ending with \\r may cause problems", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_UNEXPECTED_CARRIAGE_RETURN]        = { "encountered \\r in middle of line, treated as a mere space", PM_WARNING_LEVEL_DEFAULT },
     [PM_WARN_UNREACHABLE_STATEMENT]             = { "statement not reached", PM_WARNING_LEVEL_VERBOSE },
@@ -398,13 +407,16 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_ARGUMENT_BARE_HASH: return "argument_bare_hash";
         case PM_ERR_ARGUMENT_BLOCK_FORWARDING: return "argument_block_forwarding";
         case PM_ERR_ARGUMENT_BLOCK_MULTI: return "argument_block_multi";
+        case PM_ERR_ARGUMENT_CONFLICT_AMPERSAND: return "argument_conflict_ampersand";
+        case PM_ERR_ARGUMENT_CONFLICT_STAR: return "argument_conflict_star";
+        case PM_ERR_ARGUMENT_CONFLICT_STAR_STAR: return "argument_conflict_star_star";
         case PM_ERR_ARGUMENT_FORMAL_CLASS: return "argument_formal_class";
         case PM_ERR_ARGUMENT_FORMAL_CONSTANT: return "argument_formal_constant";
         case PM_ERR_ARGUMENT_FORMAL_GLOBAL: return "argument_formal_global";
         case PM_ERR_ARGUMENT_FORMAL_IVAR: return "argument_formal_ivar";
         case PM_ERR_ARGUMENT_FORWARDING_UNBOUND: return "argument_forwarding_unbound";
         case PM_ERR_ARGUMENT_IN: return "argument_in";
-        case PM_ERR_ARGUMENT_NO_FORWARDING_AMP: return "argument_no_forwarding_amp";
+        case PM_ERR_ARGUMENT_NO_FORWARDING_AMPERSAND: return "argument_no_forwarding_ampersand";
         case PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES: return "argument_no_forwarding_ellipses";
         case PM_ERR_ARGUMENT_NO_FORWARDING_STAR: return "argument_no_forwarding_star";
         case PM_ERR_ARGUMENT_NO_FORWARDING_STAR_STAR: return "argument_no_forwarding_star_star";
@@ -486,6 +498,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT_HASH: return "expect_expression_after_splat_hash";
         case PM_ERR_EXPECT_EXPRESSION_AFTER_STAR: return "expect_expression_after_star";
         case PM_ERR_EXPECT_IDENT_REQ_PARAMETER: return "expect_ident_req_parameter";
+        case PM_ERR_EXPECT_IN_DELIMITER: return "expect_in_delimiter";
         case PM_ERR_EXPECT_LPAREN_REQ_PARAMETER: return "expect_lparen_req_parameter";
         case PM_ERR_EXPECT_MESSAGE: return "expect_message";
         case PM_ERR_EXPECT_RBRACKET: return "expect_rbracket";
@@ -525,6 +538,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_INVALID_BLOCK_EXIT: return "invalid_block_exit";
         case PM_ERR_INVALID_CHARACTER: return "invalid_character";
         case PM_ERR_INVALID_ENCODING_MAGIC_COMMENT: return "invalid_encoding_magic_comment";
+        case PM_ERR_INVALID_ESCAPE_CHARACTER: return "invalid_escape_character";
         case PM_ERR_INVALID_FLOAT_EXPONENT: return "invalid_float_exponent";
         case PM_ERR_INVALID_LOCAL_VARIABLE_READ: return "invalid_local_variable_read";
         case PM_ERR_INVALID_LOCAL_VARIABLE_WRITE: return "invalid_local_variable_write";
@@ -533,6 +547,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_INVALID_MULTIBYTE_ESCAPE: return "invalid_multibyte_escape";
         case PM_ERR_INVALID_NUMBER_BINARY: return "invalid_number_binary";
         case PM_ERR_INVALID_NUMBER_DECIMAL: return "invalid_number_decimal";
+        case PM_ERR_INVALID_NUMBER_FRACTION: return "invalid_number_fraction";
         case PM_ERR_INVALID_NUMBER_HEXADECIMAL: return "invalid_number_hexadecimal";
         case PM_ERR_INVALID_NUMBER_OCTAL: return "invalid_number_octal";
         case PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER: return "invalid_number_underscore_inner";
@@ -578,6 +593,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_PARAMETER_ASSOC_SPLAT_MULTI: return "parameter_assoc_splat_multi";
         case PM_ERR_PARAMETER_BLOCK_MULTI: return "parameter_block_multi";
         case PM_ERR_PARAMETER_CIRCULAR: return "parameter_circular";
+        case PM_ERR_PARAMETER_FORWARDING_AFTER_REST: return "parameter_forwarding_after_rest";
         case PM_ERR_PARAMETER_METHOD_NAME: return "parameter_method_name";
         case PM_ERR_PARAMETER_NAME_DUPLICATED: return "parameter_name_duplicated";
         case PM_ERR_PARAMETER_NO_DEFAULT: return "parameter_no_default";
@@ -600,8 +616,10 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_PATTERN_EXPRESSION_AFTER_PIPE: return "pattern_expression_after_pipe";
         case PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE: return "pattern_expression_after_range";
         case PM_ERR_PATTERN_EXPRESSION_AFTER_REST: return "pattern_expression_after_rest";
+        case PM_ERR_PATTERN_HASH_IMPLICIT: return "pattern_hash_implicit";
         case PM_ERR_PATTERN_HASH_KEY: return "pattern_hash_key";
         case PM_ERR_PATTERN_HASH_KEY_DUPLICATE: return "pattern_hash_key_duplicate";
+        case PM_ERR_PATTERN_HASH_KEY_INTERPOLATED: return "pattern_hash_key_interpolated";
         case PM_ERR_PATTERN_HASH_KEY_LABEL: return "pattern_hash_key_label";
         case PM_ERR_PATTERN_HASH_KEY_LOCALS: return "pattern_hash_key_locals";
         case PM_ERR_PATTERN_IDENT_AFTER_HROCKET: return "pattern_ident_after_hrocket";
@@ -676,6 +694,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_WARN_KEYWORD_EOL: return "keyword_eol";
         case PM_WARN_LITERAL_IN_CONDITION_DEFAULT: return "literal_in_condition_default";
         case PM_WARN_LITERAL_IN_CONDITION_VERBOSE: return "literal_in_condition_verbose";
+        case PM_WARN_SHAREABLE_CONSTANT_VALUE_LINE: return "shareable_constant_value_line";
         case PM_WARN_SHEBANG_CARRIAGE_RETURN: return "shebang_carriage_return";
         case PM_WARN_UNEXPECTED_CARRIAGE_RETURN: return "unexpected_carriage_return";
         case PM_WARN_UNREACHABLE_STATEMENT: return "unreachable_statement";

data/src/node.c

@@ -5169,15 +5169,15 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             pm_buffer_append_string(buffer, "\"write_name\":", 13);
             pm_dump_json_constant(buffer, parser, cast->write_name);
 
-            // Dump the operator field
+            // Dump the binary_operator field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator\":", 11);
-            pm_dump_json_constant(buffer, parser, cast->operator);
+            pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
+            pm_dump_json_constant(buffer, parser, cast->binary_operator);
 
-            // Dump the operator_loc field
+            // Dump the binary_operator_loc field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
-            pm_dump_json_location(buffer, parser, &cast->operator_loc);
+            pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
+            pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
 
             // Dump the value field
             pm_buffer_append_byte(buffer, ',');
@@ -5561,20 +5561,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             pm_buffer_append_string(buffer, "\"name_loc\":", 11);
             pm_dump_json_location(buffer, parser, &cast->name_loc);
 
-            // Dump the operator_loc field
+            // Dump the binary_operator_loc field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
-            pm_dump_json_location(buffer, parser, &cast->operator_loc);
+            pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
+            pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
 
             // Dump the value field
             pm_buffer_append_byte(buffer, ',');
             pm_buffer_append_string(buffer, "\"value\":", 8);
             pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
 
-            // Dump the operator field
+            // Dump the binary_operator field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator\":", 11);
-            pm_dump_json_constant(buffer, parser, cast->operator);
+            pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
+            pm_dump_json_constant(buffer, parser, cast->binary_operator);
 
             pm_buffer_append_byte(buffer, '}');
             break;
@@ -5710,20 +5710,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             pm_buffer_append_string(buffer, "\"name_loc\":", 11);
             pm_dump_json_location(buffer, parser, &cast->name_loc);
 
-            // Dump the operator_loc field
+            // Dump the binary_operator_loc field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
-            pm_dump_json_location(buffer, parser, &cast->operator_loc);
+            pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
+            pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
 
             // Dump the value field
             pm_buffer_append_byte(buffer, ',');
             pm_buffer_append_string(buffer, "\"value\":", 8);
             pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
 
-            // Dump the operator field
+            // Dump the binary_operator field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator\":", 11);
-            pm_dump_json_constant(buffer, parser, cast->operator);
+            pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
+            pm_dump_json_constant(buffer, parser, cast->binary_operator);
 
             pm_buffer_append_byte(buffer, '}');
             break;
@@ -5829,20 +5829,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             pm_buffer_append_string(buffer, "\"target\":", 9);
             pm_dump_json(buffer, parser, (const pm_node_t *) cast->target);
 
-            // Dump the operator_loc field
+            // Dump the binary_operator_loc field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
-            pm_dump_json_location(buffer, parser, &cast->operator_loc);
+            pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
+            pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
 
             // Dump the value field
             pm_buffer_append_byte(buffer, ',');
             pm_buffer_append_string(buffer, "\"value\":", 8);
             pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
 
-            // Dump the operator field
+            // Dump the binary_operator field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator\":", 11);
-            pm_dump_json_constant(buffer, parser, cast->operator);
+            pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
+            pm_dump_json_constant(buffer, parser, cast->binary_operator);
 
             pm_buffer_append_byte(buffer, '}');
             break;
@@ -6499,20 +6499,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             pm_buffer_append_string(buffer, "\"name_loc\":", 11);
             pm_dump_json_location(buffer, parser, &cast->name_loc);
 
-            // Dump the operator_loc field
+            // Dump the binary_operator_loc field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
-            pm_dump_json_location(buffer, parser, &cast->operator_loc);
+            pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
+            pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
 
             // Dump the value field
             pm_buffer_append_byte(buffer, ',');
             pm_buffer_append_string(buffer, "\"value\":", 8);
             pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
 
-            // Dump the operator field
+            // Dump the binary_operator field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator\":", 11);
-            pm_dump_json_constant(buffer, parser, cast->operator);
+            pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
+            pm_dump_json_constant(buffer, parser, cast->binary_operator);
 
             pm_buffer_append_byte(buffer, '}');
             break;
@@ -6995,15 +6995,15 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
                 pm_buffer_append_string(buffer, "null", 4);
             }
 
-            // Dump the operator field
+            // Dump the binary_operator field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator\":", 11);
-            pm_dump_json_constant(buffer, parser, cast->operator);
+            pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
+            pm_dump_json_constant(buffer, parser, cast->binary_operator);
 
-            // Dump the operator_loc field
+            // Dump the binary_operator_loc field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
-            pm_dump_json_location(buffer, parser, &cast->operator_loc);
+            pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
+            pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
 
             // Dump the value field
             pm_buffer_append_byte(buffer, ',');
@@ -7219,20 +7219,20 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             pm_buffer_append_string(buffer, "\"name_loc\":", 11);
             pm_dump_json_location(buffer, parser, &cast->name_loc);
 
-            // Dump the operator_loc field
+            // Dump the binary_operator_loc field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
-            pm_dump_json_location(buffer, parser, &cast->operator_loc);
+            pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
+            pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
 
             // Dump the value field
             pm_buffer_append_byte(buffer, ',');
             pm_buffer_append_string(buffer, "\"value\":", 8);
             pm_dump_json(buffer, parser, (const pm_node_t *) cast->value);
 
-            // Dump the operator field
+            // Dump the binary_operator field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator\":", 11);
-            pm_dump_json_constant(buffer, parser, cast->operator);
+            pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
+            pm_dump_json_constant(buffer, parser, cast->binary_operator);
 
             pm_buffer_append_byte(buffer, '}');
             break;
@@ -7861,10 +7861,10 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             pm_buffer_append_string(buffer, "\"name_loc\":", 11);
             pm_dump_json_location(buffer, parser, &cast->name_loc);
 
-            // Dump the operator_loc field
+            // Dump the binary_operator_loc field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator_loc\":", 15);
-            pm_dump_json_location(buffer, parser, &cast->operator_loc);
+            pm_buffer_append_string(buffer, "\"binary_operator_loc\":", 22);
+            pm_dump_json_location(buffer, parser, &cast->binary_operator_loc);
 
             // Dump the value field
             pm_buffer_append_byte(buffer, ',');
@@ -7876,10 +7876,10 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
             pm_buffer_append_string(buffer, "\"name\":", 7);
             pm_dump_json_constant(buffer, parser, cast->name);
 
-            // Dump the operator field
+            // Dump the binary_operator field
             pm_buffer_append_byte(buffer, ',');
-            pm_buffer_append_string(buffer, "\"operator\":", 11);
-            pm_dump_json_constant(buffer, parser, cast->operator);
+            pm_buffer_append_string(buffer, "\"binary_operator\":", 18);
+            pm_dump_json_constant(buffer, parser, cast->binary_operator);
 
             // Dump the depth field
             pm_buffer_append_byte(buffer, ',');