yarp 0.10.0 → 0.12.0

data/include/yarp/diagnostic.h

@@ -6,6 +6,7 @@
 
 #include <stdbool.h>
 #include <stdlib.h>
+#include <assert.h>
 
 // This struct represents a diagnostic found during parsing.
 typedef struct {
@@ -15,8 +16,209 @@ typedef struct {
     const char *message;
 } yp_diagnostic_t;
 
+typedef enum {
+    YP_ERR_ALIAS_ARGUMENT,
+    YP_ERR_AMPAMPEQ_MULTI_ASSIGN,
+    YP_ERR_ARGUMENT_AFTER_BLOCK,
+    YP_ERR_ARGUMENT_BARE_HASH,
+    YP_ERR_ARGUMENT_BLOCK_MULTI,
+    YP_ERR_ARGUMENT_FORMAL_CLASS,
+    YP_ERR_ARGUMENT_FORMAL_CONSTANT,
+    YP_ERR_ARGUMENT_FORMAL_GLOBAL,
+    YP_ERR_ARGUMENT_FORMAL_IVAR,
+    YP_ERR_ARGUMENT_NO_FORWARDING_AMP,
+    YP_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES,
+    YP_ERR_ARGUMENT_NO_FORWARDING_STAR,
+    YP_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT,
+    YP_ERR_ARGUMENT_SPLAT_AFTER_SPLAT,
+    YP_ERR_ARGUMENT_TERM_PAREN,
+    YP_ERR_ARGUMENT_UNEXPECTED_BLOCK,
+    YP_ERR_ARRAY_ELEMENT,
+    YP_ERR_ARRAY_EXPRESSION,
+    YP_ERR_ARRAY_EXPRESSION_AFTER_STAR,
+    YP_ERR_ARRAY_SEPARATOR,
+    YP_ERR_ARRAY_TERM,
+    YP_ERR_BEGIN_LONELY_ELSE,
+    YP_ERR_BEGIN_TERM,
+    YP_ERR_BEGIN_UPCASE_BRACE,
+    YP_ERR_BEGIN_UPCASE_TERM,
+    YP_ERR_BLOCK_PARAM_LOCAL_VARIABLE,
+    YP_ERR_BLOCK_PARAM_PIPE_TERM,
+    YP_ERR_BLOCK_TERM_BRACE,
+    YP_ERR_BLOCK_TERM_END,
+    YP_ERR_CANNOT_PARSE_EXPRESSION,
+    YP_ERR_CANNOT_PARSE_STRING_PART,
+    YP_ERR_CASE_EXPRESSION_AFTER_CASE,
+    YP_ERR_CASE_EXPRESSION_AFTER_WHEN,
+    YP_ERR_CASE_MISSING_CONDITIONS,
+    YP_ERR_CASE_TERM,
+    YP_ERR_CLASS_IN_METHOD,
+    YP_ERR_CLASS_NAME,
+    YP_ERR_CLASS_SUPERCLASS,
+    YP_ERR_CLASS_TERM,
+    YP_ERR_CONDITIONAL_ELSIF_PREDICATE,
+    YP_ERR_CONDITIONAL_IF_PREDICATE,
+    YP_ERR_CONDITIONAL_TERM,
+    YP_ERR_CONDITIONAL_TERM_ELSE,
+    YP_ERR_CONDITIONAL_UNLESS_PREDICATE,
+    YP_ERR_CONDITIONAL_UNTIL_PREDICATE,
+    YP_ERR_CONDITIONAL_WHILE_PREDICATE,
+    YP_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT,
+    YP_ERR_DEF_ENDLESS,
+    YP_ERR_DEF_ENDLESS_SETTER,
+    YP_ERR_DEF_NAME,
+    YP_ERR_DEF_NAME_AFTER_RECEIVER,
+    YP_ERR_DEF_PARAMS_TERM,
+    YP_ERR_DEF_PARAMS_TERM_PAREN,
+    YP_ERR_DEF_RECEIVER,
+    YP_ERR_DEF_RECEIVER_TERM,
+    YP_ERR_DEF_TERM,
+    YP_ERR_DEFINED_EXPRESSION,
+    YP_ERR_EMBDOC_TERM,
+    YP_ERR_EMBEXPR_END,
+    YP_ERR_EMBVAR_INVALID,
+    YP_ERR_END_UPCASE_BRACE,
+    YP_ERR_END_UPCASE_TERM,
+    YP_ERR_ESCAPE_INVALID_CONTROL,
+    YP_ERR_ESCAPE_INVALID_CONTROL_REPEAT,
+    YP_ERR_ESCAPE_INVALID_HEXADECIMAL,
+    YP_ERR_ESCAPE_INVALID_META,
+    YP_ERR_ESCAPE_INVALID_META_REPEAT,
+    YP_ERR_ESCAPE_INVALID_UNICODE,
+    YP_ERR_ESCAPE_INVALID_UNICODE_CM_FLAGS,
+    YP_ERR_ESCAPE_INVALID_UNICODE_LITERAL,
+    YP_ERR_ESCAPE_INVALID_UNICODE_LONG,
+    YP_ERR_ESCAPE_INVALID_UNICODE_TERM,
+    YP_ERR_EXPECT_ARGUMENT,
+    YP_ERR_EXPECT_EOL_AFTER_STATEMENT,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_COMMA,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_EQUAL,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_LESS_LESS,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_LPAREN,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_QUESTION,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_SPLAT,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_SPLAT_HASH,
+    YP_ERR_EXPECT_EXPRESSION_AFTER_STAR,
+    YP_ERR_EXPECT_IDENT_REQ_PARAMETER,
+    YP_ERR_EXPECT_LPAREN_REQ_PARAMETER,
+    YP_ERR_EXPECT_RBRACKET,
+    YP_ERR_EXPECT_RPAREN,
+    YP_ERR_EXPECT_RPAREN_AFTER_MULTI,
+    YP_ERR_EXPECT_RPAREN_REQ_PARAMETER,
+    YP_ERR_EXPECT_STRING_CONTENT,
+    YP_ERR_EXPECT_WHEN_DELIMITER,
+    YP_ERR_EXPRESSION_BARE_HASH,
+    YP_ERR_FOR_COLLECTION,
+    YP_ERR_FOR_IN,
+    YP_ERR_FOR_INDEX,
+    YP_ERR_FOR_TERM,
+    YP_ERR_HASH_EXPRESSION_AFTER_LABEL,
+    YP_ERR_HASH_KEY,
+    YP_ERR_HASH_ROCKET,
+    YP_ERR_HASH_TERM,
+    YP_ERR_HASH_VALUE,
+    YP_ERR_HEREDOC_TERM,
+    YP_ERR_INCOMPLETE_QUESTION_MARK,
+    YP_ERR_INCOMPLETE_VARIABLE_CLASS,
+    YP_ERR_INCOMPLETE_VARIABLE_INSTANCE,
+    YP_ERR_INVALID_ENCODING_MAGIC_COMMENT,
+    YP_ERR_INVALID_FLOAT_EXPONENT,
+    YP_ERR_INVALID_NUMBER_BINARY,
+    YP_ERR_INVALID_NUMBER_DECIMAL,
+    YP_ERR_INVALID_NUMBER_HEXADECIMAL,
+    YP_ERR_INVALID_NUMBER_OCTAL,
+    YP_ERR_INVALID_NUMBER_UNDERSCORE,
+    YP_ERR_INVALID_PERCENT,
+    YP_ERR_INVALID_TOKEN,
+    YP_ERR_INVALID_VARIABLE_GLOBAL,
+    YP_ERR_LAMBDA_OPEN,
+    YP_ERR_LAMBDA_TERM_BRACE,
+    YP_ERR_LAMBDA_TERM_END,
+    YP_ERR_LIST_I_LOWER_ELEMENT,
+    YP_ERR_LIST_I_LOWER_TERM,
+    YP_ERR_LIST_I_UPPER_ELEMENT,
+    YP_ERR_LIST_I_UPPER_TERM,
+    YP_ERR_LIST_W_LOWER_ELEMENT,
+    YP_ERR_LIST_W_LOWER_TERM,
+    YP_ERR_LIST_W_UPPER_ELEMENT,
+    YP_ERR_LIST_W_UPPER_TERM,
+    YP_ERR_MALLOC_FAILED,
+    YP_ERR_MODULE_IN_METHOD,
+    YP_ERR_MODULE_NAME,
+    YP_ERR_MODULE_TERM,
+    YP_ERR_MULTI_ASSIGN_MULTI_SPLATS,
+    YP_ERR_NOT_EXPRESSION,
+    YP_ERR_NUMBER_LITERAL_UNDERSCORE,
+    YP_ERR_NUMBERED_PARAMETER_NOT_ALLOWED,
+    YP_ERR_NUMBERED_PARAMETER_OUTER_SCOPE,
+    YP_ERR_OPERATOR_MULTI_ASSIGN,
+    YP_ERR_OPERATOR_WRITE_BLOCK,
+    YP_ERR_PARAMETER_ASSOC_SPLAT_MULTI,
+    YP_ERR_PARAMETER_BLOCK_MULTI,
+    YP_ERR_PARAMETER_NAME_REPEAT,
+    YP_ERR_PARAMETER_NO_DEFAULT,
+    YP_ERR_PARAMETER_NO_DEFAULT_KW,
+    YP_ERR_PARAMETER_NUMBERED_RESERVED,
+    YP_ERR_PARAMETER_ORDER,
+    YP_ERR_PARAMETER_SPLAT_MULTI,
+    YP_ERR_PARAMETER_STAR,
+    YP_ERR_PARAMETER_WILD_LOOSE_COMMA,
+    YP_ERR_PATTERN_EXPRESSION_AFTER_BRACKET,
+    YP_ERR_PATTERN_EXPRESSION_AFTER_HROCKET,
+    YP_ERR_PATTERN_EXPRESSION_AFTER_COMMA,
+    YP_ERR_PATTERN_EXPRESSION_AFTER_IN,
+    YP_ERR_PATTERN_EXPRESSION_AFTER_KEY,
+    YP_ERR_PATTERN_EXPRESSION_AFTER_PAREN,
+    YP_ERR_PATTERN_EXPRESSION_AFTER_PIN,
+    YP_ERR_PATTERN_EXPRESSION_AFTER_PIPE,
+    YP_ERR_PATTERN_EXPRESSION_AFTER_RANGE,
+    YP_ERR_PATTERN_HASH_KEY,
+    YP_ERR_PATTERN_HASH_KEY_LABEL,
+    YP_ERR_PATTERN_IDENT_AFTER_HROCKET,
+    YP_ERR_PATTERN_LABEL_AFTER_COMMA,
+    YP_ERR_PATTERN_REST,
+    YP_ERR_PATTERN_TERM_BRACE,
+    YP_ERR_PATTERN_TERM_BRACKET,
+    YP_ERR_PATTERN_TERM_PAREN,
+    YP_ERR_PIPEPIPEEQ_MULTI_ASSIGN,
+    YP_ERR_REGEXP_TERM,
+    YP_ERR_RESCUE_EXPRESSION,
+    YP_ERR_RESCUE_MODIFIER_VALUE,
+    YP_ERR_RESCUE_TERM,
+    YP_ERR_RESCUE_VARIABLE,
+    YP_ERR_RETURN_INVALID,
+    YP_ERR_STRING_CONCATENATION,
+    YP_ERR_STRING_INTERPOLATED_TERM,
+    YP_ERR_STRING_LITERAL_TERM,
+    YP_ERR_SYMBOL_INVALID,
+    YP_ERR_SYMBOL_TERM_DYNAMIC,
+    YP_ERR_SYMBOL_TERM_INTERPOLATED,
+    YP_ERR_TERNARY_COLON,
+    YP_ERR_TERNARY_EXPRESSION_FALSE,
+    YP_ERR_TERNARY_EXPRESSION_TRUE,
+    YP_ERR_UNARY_RECEIVER_BANG,
+    YP_ERR_UNARY_RECEIVER_MINUS,
+    YP_ERR_UNARY_RECEIVER_PLUS,
+    YP_ERR_UNARY_RECEIVER_TILDE,
+    YP_ERR_UNDEF_ARGUMENT,
+    YP_ERR_UNTIL_TERM,
+    YP_ERR_WHILE_TERM,
+    YP_ERR_WRITE_TARGET_READONLY,
+    YP_ERR_WRITE_TARGET_UNEXPECTED,
+    YP_ERR_XSTRING_TERM,
+    YP_WARN_AMBIGUOUS_FIRST_ARGUMENT_MINUS,
+    YP_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS,
+    YP_WARN_AMBIGUOUS_PREFIX_STAR,
+    YP_WARN_AMBIGUOUS_SLASH,
+    /* This must be the last member. */
+    YP_DIAGNOSTIC_ID_LEN,
+} yp_diagnostic_id_t;
+
 // Append a diagnostic to the given list of diagnostics.
-bool yp_diagnostic_list_append(yp_list_t *list, const uint8_t *start, const uint8_t *end, const char *message);
+bool yp_diagnostic_list_append(yp_list_t *list, const uint8_t *start, const uint8_t *end, yp_diagnostic_id_t diag_id);
 
 // Deallocate the internal state of the given diagnostic list.
 void yp_diagnostic_list_free(yp_list_t *list);

data/include/yarp/enc/yp_encoding.h

@@ -60,7 +60,7 @@ size_t yp_encoding_utf_8_alnum_char(const uint8_t *b, ptrdiff_t n);
 
 // This lookup table is referenced in both the UTF-8 encoding file and the
 // parser directly in order to speed up the default encoding processing.
-extern uint8_t yp_encoding_unicode_table[256];
+extern const uint8_t yp_encoding_unicode_table[256];
 
 // These are the encodings that are supported by the parser. They are defined in
 // their own files in the src/enc directory.

data/include/yarp/node.h

@@ -4,9 +4,6 @@
 #include "yarp/defines.h"
 #include "yarp/parser.h"
 
-// Append a token to the given list.
-void yp_location_list_append(yp_location_list_t *list, const yp_token_t *token);
-
 // Append a new node onto the end of the node list.
 void yp_node_list_append(yp_node_list_t *list, yp_node_t *node);
 
@@ -31,7 +28,6 @@ YP_EXPORTED_FUNCTION void yp_node_memsize(yp_node_t *node, yp_memsize_t *memsize
 YP_EXPORTED_FUNCTION const char * yp_node_type_to_str(yp_node_type_t node_type);
 
 #define YP_EMPTY_NODE_LIST ((yp_node_list_t) { .nodes = NULL, .size = 0, .capacity = 0 })
-#define YP_EMPTY_LOCATION_LIST ((yp_location_list_t) { .locations = NULL, .size = 0, .capacity = 0 })
 
 #endif // YARP_NODE_H
 

data/include/yarp/parser.h

@@ -277,12 +277,22 @@ typedef struct yp_scope {
     // The IDs of the locals in the given scope.
     yp_constant_id_list_t locals;
 
+    // A pointer to the previous scope in the linked list.
+    struct yp_scope *previous;
+
     // A boolean indicating whether or not this scope can see into its parent.
     // If closed is true, then the scope cannot see into its parent.
     bool closed;
 
-    // A pointer to the previous scope in the linked list.
-    struct yp_scope *previous;
+    // A boolean indicating whether or not this scope has explicit parameters.
+    // This is necessary to determine whether or not numbered parameters are
+    // allowed.
+    bool explicit_params;
+
+    // A boolean indicating whether or not this scope has numbered parameters.
+    // This is necessary to determine if child blocks are allowed to use
+    // numbered parameters.
+    bool numbered_params;
 } yp_scope_t;
 
 // This struct represents the overall parser. It contains a reference to the
@@ -291,7 +301,6 @@ typedef struct yp_scope {
 // it's considering.
 struct yp_parser {
     yp_lex_state_t lex_state; // the current state of the lexer
-    bool command_start;       // whether or not we're at the beginning of a command
     int enclosure_nesting;    // tracks the current nesting of (), [], and {}
 
     // Used to temporarily track the nesting of enclosures to determine if a {
@@ -338,17 +347,11 @@ struct yp_parser {
     yp_scope_t *current_scope;          // the current local scope
 
     yp_context_node_t *current_context; // the current parsing context
-    bool recovering; // whether or not we're currently recovering from a syntax error
 
     // The encoding functions for the current file is attached to the parser as
     // it's parsing so that it can change with a magic comment.
     yp_encoding_t encoding;
 
-    // Whether or not the encoding has been changed by a magic comment. We use
-    // this to provide a fast path for the lexer instead of going through the
-    // function pointer.
-    bool encoding_changed;
-
     // When the encoding that is being used to parse the source is changed by
     // YARP, we provide the ability here to call out to a user-defined function.
     yp_encoding_changed_callback_t encoding_changed_callback;
@@ -367,13 +370,6 @@ struct yp_parser {
     // be called whenever a new token is lexed by the parser.
     yp_lex_callback_t *lex_callback;
 
-    // This flag indicates that we are currently parsing a pattern matching
-    // expression and impacts that calculation of newlines.
-    bool pattern_matching_newlines;
-
-    // This flag indicates that we are currently parsing a keyword argument.
-    bool in_keyword_arg;
-
     // This is the path of the file being parsed
     // We use the filepath when constructing SourceFileNodes
     yp_string_t filepath_string;
@@ -384,6 +380,38 @@ struct yp_parser {
 
     // This is the list of newline offsets in the source file.
     yp_newline_list_t newline_list;
+
+    // We want to add a flag to integer nodes that indicates their base. We only
+    // want to parse these once, but we don't have space on the token itself to
+    // communicate this information. So we store it here and pass it through
+    // when we find tokens that we need it for.
+    yp_node_flags_t integer_base;
+
+    // Whether or not we're at the beginning of a command
+    bool command_start;
+
+    // Whether or not we're currently recovering from a syntax error
+    bool recovering;
+
+    // Whether or not the encoding has been changed by a magic comment. We use
+    // this to provide a fast path for the lexer instead of going through the
+    // function pointer.
+    bool encoding_changed;
+
+    // This flag indicates that we are currently parsing a pattern matching
+    // expression and impacts that calculation of newlines.
+    bool pattern_matching_newlines;
+
+    // This flag indicates that we are currently parsing a keyword argument.
+    bool in_keyword_arg;
+
+    // Whether or not the parser has seen a token that has semantic meaning
+    // (i.e., a token that is not a comment or whitespace).
+    bool semantic_token_seen;
+
+    // Whether or not we have found a frozen_string_literal magic comment with
+    // a true value.
+    bool frozen_string_literal;
 };
 
 #endif // YARP_PARSER_H

data/include/yarp/util/yp_char.h

@@ -15,7 +15,7 @@ size_t yp_strspn_whitespace(const uint8_t *string, ptrdiff_t length);
 // whitespace while also tracking the location of each newline. Disallows
 // searching past the given maximum number of characters.
 size_t
-yp_strspn_whitespace_newlines(const uint8_t *string, ptrdiff_t length, yp_newline_list_t *newline_list, bool stop_at_newline);
+yp_strspn_whitespace_newlines(const uint8_t *string, ptrdiff_t length, yp_newline_list_t *newline_list);
 
 // Returns the number of characters at the start of the string that are inline
 // whitespace. Disallows searching past the given maximum number of characters.
@@ -31,19 +31,31 @@ size_t yp_strspn_decimal_digit(const uint8_t *string, ptrdiff_t length);
 size_t yp_strspn_hexadecimal_digit(const uint8_t *string, ptrdiff_t length);
 
 // Returns the number of characters at the start of the string that are octal
-// digits or underscores.  Disallows searching past the given maximum number of
+// digits or underscores. Disallows searching past the given maximum number of
 // characters.
-size_t yp_strspn_octal_number(const uint8_t *string, ptrdiff_t length);
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
+size_t yp_strspn_octal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid);
 
 // Returns the number of characters at the start of the string that are decimal
 // digits or underscores. Disallows searching past the given maximum number of
 // characters.
-size_t yp_strspn_decimal_number(const uint8_t *string, ptrdiff_t length);
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
+size_t yp_strspn_decimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid);
 
 // Returns the number of characters at the start of the string that are
 // hexadecimal digits or underscores. Disallows searching past the given maximum
 // number of characters.
-size_t yp_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length);
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
+size_t yp_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid);
 
 // Returns the number of characters at the start of the string that are regexp
 // options. Disallows searching past the given maximum number of characters.
@@ -52,7 +64,11 @@ size_t yp_strspn_regexp_option(const uint8_t *string, ptrdiff_t length);
 // Returns the number of characters at the start of the string that are binary
 // digits or underscores. Disallows searching past the given maximum number of
 // characters.
-size_t yp_strspn_binary_number(const uint8_t *string, ptrdiff_t length);
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
+size_t yp_strspn_binary_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid);
 
 // Returns true if the given character is a whitespace character.
 bool yp_char_is_whitespace(const uint8_t b);

data/include/yarp/util/yp_constant_pool.h

@@ -8,6 +8,7 @@
 
 #include "yarp/defines.h"
 
+#include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -39,7 +40,8 @@ size_t yp_constant_id_list_memsize(yp_constant_id_list_t *list);
 void yp_constant_id_list_free(yp_constant_id_list_t *list);
 
 typedef struct {
-    yp_constant_id_t id;
+    unsigned int id: 31;
+    bool owned: 1;
     const uint8_t *start;
     size_t length;
     size_t hash;
@@ -57,9 +59,14 @@ typedef struct {
 // Initialize a new constant pool with a given capacity.
 bool yp_constant_pool_init(yp_constant_pool_t *pool, size_t capacity);
 
-// Insert a constant into a constant pool. Returns the id of the constant, or 0
-// if any potential calls to resize fail.
-yp_constant_id_t yp_constant_pool_insert(yp_constant_pool_t *pool, const uint8_t *start, size_t length);
+// Insert a constant into a constant pool that is a slice of a source string.
+// Returns the id of the constant, or 0 if any potential calls to resize fail.
+yp_constant_id_t yp_constant_pool_insert_shared(yp_constant_pool_t *pool, const uint8_t *start, size_t length);
+
+// Insert a constant into a constant pool from memory that is now owned by the
+// constant pool. Returns the id of the constant, or 0 if any potential calls to
+// resize fail.
+yp_constant_id_t yp_constant_pool_insert_owned(yp_constant_pool_t *pool, const uint8_t *start, size_t length);
 
 // Free the memory associated with a constant pool.
 void yp_constant_pool_free(yp_constant_pool_t *pool);

data/include/yarp/version.h

@@ -1,4 +1,4 @@
 #define YP_VERSION_MAJOR 0
-#define YP_VERSION_MINOR 10
+#define YP_VERSION_MINOR 12
 #define YP_VERSION_PATCH 0
-#define YP_VERSION "0.10.0"
+#define YP_VERSION "0.12.0"

data/lib/yarp/desugar_visitor.rb

@@ -8,7 +8,7 @@ module YARP
     #
     # @@foo && @@foo = bar
     def visit_class_variable_and_write_node(node)
-      desugar_and_write_node(node, ClassVariableReadNode, ClassVariableWriteNode, arguments: [node.name])
+      desugar_and_write_node(node, ClassVariableReadNode, ClassVariableWriteNode, node.name)
     end
 
     # @@foo ||= bar
@@ -17,7 +17,7 @@ module YARP
     #
     # defined?(@@foo) ? @@foo : @@foo = bar
     def visit_class_variable_or_write_node(node)
-      desugar_or_write_defined_node(node, ClassVariableReadNode, ClassVariableWriteNode, arguments: [node.name])
+      desugar_or_write_defined_node(node, ClassVariableReadNode, ClassVariableWriteNode, node.name)
     end
 
     # @@foo += bar
@@ -26,7 +26,7 @@ module YARP
     #
     # @@foo = @@foo + bar
     def visit_class_variable_operator_write_node(node)
-      desugar_operator_write_node(node, ClassVariableReadNode, ClassVariableWriteNode, arguments: [node.name])
+      desugar_operator_write_node(node, ClassVariableReadNode, ClassVariableWriteNode, node.name)
     end
 
     # Foo &&= bar
@@ -35,7 +35,7 @@ module YARP
     #
     # Foo && Foo = bar
     def visit_constant_and_write_node(node)
-      desugar_and_write_node(node, ConstantReadNode, ConstantWriteNode)
+      desugar_and_write_node(node, ConstantReadNode, ConstantWriteNode, node.name)
     end
 
     # Foo ||= bar
@@ -44,7 +44,7 @@ module YARP
     #
     # defined?(Foo) ? Foo : Foo = bar
     def visit_constant_or_write_node(node)
-      desugar_or_write_defined_node(node, ConstantReadNode, ConstantWriteNode)
+      desugar_or_write_defined_node(node, ConstantReadNode, ConstantWriteNode, node.name)
     end
 
     # Foo += bar
@@ -53,7 +53,7 @@ module YARP
     #
     # Foo = Foo + bar
     def visit_constant_operator_write_node(node)
-      desugar_operator_write_node(node, ConstantReadNode, ConstantWriteNode)
+      desugar_operator_write_node(node, ConstantReadNode, ConstantWriteNode, node.name)
     end
 
     # $foo &&= bar
@@ -62,7 +62,7 @@ module YARP
     #
     # $foo && $foo = bar
     def visit_global_variable_and_write_node(node)
-      desugar_and_write_node(node, GlobalVariableReadNode, GlobalVariableWriteNode)
+      desugar_and_write_node(node, GlobalVariableReadNode, GlobalVariableWriteNode, node.name)
     end
 
     # $foo ||= bar
@@ -71,7 +71,7 @@ module YARP
     #
     # defined?($foo) ? $foo : $foo = bar
     def visit_global_variable_or_write_node(node)
-      desugar_or_write_defined_node(node, GlobalVariableReadNode, GlobalVariableWriteNode)
+      desugar_or_write_defined_node(node, GlobalVariableReadNode, GlobalVariableWriteNode, node.name)
     end
 
     # $foo += bar
@@ -80,7 +80,7 @@ module YARP
     #
     # $foo = $foo + bar
     def visit_global_variable_operator_write_node(node)
-      desugar_operator_write_node(node, GlobalVariableReadNode, GlobalVariableWriteNode)
+      desugar_operator_write_node(node, GlobalVariableReadNode, GlobalVariableWriteNode, node.name)
     end
 
     # @foo &&= bar
@@ -89,7 +89,7 @@ module YARP
     #
     # @foo && @foo = bar
     def visit_instance_variable_and_write_node(node)
-      desugar_and_write_node(node, InstanceVariableReadNode, InstanceVariableWriteNode, arguments: [node.name])
+      desugar_and_write_node(node, InstanceVariableReadNode, InstanceVariableWriteNode, node.name)
     end
 
     # @foo ||= bar
@@ -98,7 +98,7 @@ module YARP
     #
     # @foo || @foo = bar
     def visit_instance_variable_or_write_node(node)
-      desugar_or_write_node(node, InstanceVariableReadNode, InstanceVariableWriteNode, arguments: [node.name])
+      desugar_or_write_node(node, InstanceVariableReadNode, InstanceVariableWriteNode, node.name)
     end
 
     # @foo += bar
@@ -107,7 +107,7 @@ module YARP
     #
     # @foo = @foo + bar
     def visit_instance_variable_operator_write_node(node)
-      desugar_operator_write_node(node, InstanceVariableReadNode, InstanceVariableWriteNode, arguments: [node.name])
+      desugar_operator_write_node(node, InstanceVariableReadNode, InstanceVariableWriteNode, node.name)
     end
 
     # foo &&= bar
@@ -116,7 +116,7 @@ module YARP
     #
     # foo && foo = bar
     def visit_local_variable_and_write_node(node)
-      desugar_and_write_node(node, LocalVariableReadNode, LocalVariableWriteNode, arguments: [node.name, node.depth])
+      desugar_and_write_node(node, LocalVariableReadNode, LocalVariableWriteNode, node.name, node.depth)
     end
 
     # foo ||= bar
@@ -125,7 +125,7 @@ module YARP
     #
     # foo || foo = bar
     def visit_local_variable_or_write_node(node)
-      desugar_or_write_node(node, LocalVariableReadNode, LocalVariableWriteNode, arguments: [node.name, node.depth])
+      desugar_or_write_node(node, LocalVariableReadNode, LocalVariableWriteNode, node.name, node.depth)
     end
 
     # foo += bar
@@ -134,13 +134,13 @@ module YARP
     #
     # foo = foo + bar
     def visit_local_variable_operator_write_node(node)
-      desugar_operator_write_node(node, LocalVariableReadNode, LocalVariableWriteNode, arguments: [node.name, node.depth])
+      desugar_operator_write_node(node, LocalVariableReadNode, LocalVariableWriteNode, node.name, node.depth)
     end
 
     private
 
     # Desugar `x &&= y` to `x && x = y`
-    def desugar_and_write_node(node, read_class, write_class, arguments: [])
+    def desugar_and_write_node(node, read_class, write_class, *arguments)
       AndNode.new(
         read_class.new(*arguments, node.name_loc),
         write_class.new(*arguments, node.name_loc, node.value, node.operator_loc, node.location),
@@ -150,7 +150,7 @@ module YARP
     end
 
     # Desugar `x += y` to `x = x + y`
-    def desugar_operator_write_node(node, read_class, write_class, arguments: [])
+    def desugar_operator_write_node(node, read_class, write_class, *arguments)
       write_class.new(
         *arguments,
         node.name_loc,
@@ -172,7 +172,7 @@ module YARP
     end
 
     # Desugar `x ||= y` to `x || x = y`
-    def desugar_or_write_node(node, read_class, write_class, arguments: [])
+    def desugar_or_write_node(node, read_class, write_class, *arguments)
       OrNode.new(
         read_class.new(*arguments, node.name_loc),
         write_class.new(*arguments, node.name_loc, node.value, node.operator_loc, node.location),
@@ -182,7 +182,7 @@ module YARP
     end
 
     # Desugar `x ||= y` to `defined?(x) ? x : x = y`
-    def desugar_or_write_defined_node(node, read_class, write_class, arguments: [])
+    def desugar_or_write_defined_node(node, read_class, write_class, *arguments)
       IfNode.new(
         node.operator_loc,
         DefinedNode.new(nil, read_class.new(*arguments, node.name_loc), nil, node.operator_loc, node.name_loc),