prism 0.14.0 → 0.15.0

data/include/prism/ast.h

@@ -277,79 +277,82 @@ enum pm_node_type {
     PM_IMAGINARY_NODE = 66,
     PM_IMPLICIT_NODE = 67,
     PM_IN_NODE = 68,
-    PM_INSTANCE_VARIABLE_AND_WRITE_NODE = 69,
-    PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE = 70,
-    PM_INSTANCE_VARIABLE_OR_WRITE_NODE = 71,
-    PM_INSTANCE_VARIABLE_READ_NODE = 72,
-    PM_INSTANCE_VARIABLE_TARGET_NODE = 73,
-    PM_INSTANCE_VARIABLE_WRITE_NODE = 74,
-    PM_INTEGER_NODE = 75,
-    PM_INTERPOLATED_MATCH_LAST_LINE_NODE = 76,
-    PM_INTERPOLATED_REGULAR_EXPRESSION_NODE = 77,
-    PM_INTERPOLATED_STRING_NODE = 78,
-    PM_INTERPOLATED_SYMBOL_NODE = 79,
-    PM_INTERPOLATED_X_STRING_NODE = 80,
-    PM_KEYWORD_HASH_NODE = 81,
-    PM_KEYWORD_PARAMETER_NODE = 82,
-    PM_KEYWORD_REST_PARAMETER_NODE = 83,
-    PM_LAMBDA_NODE = 84,
-    PM_LOCAL_VARIABLE_AND_WRITE_NODE = 85,
-    PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE = 86,
-    PM_LOCAL_VARIABLE_OR_WRITE_NODE = 87,
-    PM_LOCAL_VARIABLE_READ_NODE = 88,
-    PM_LOCAL_VARIABLE_TARGET_NODE = 89,
-    PM_LOCAL_VARIABLE_WRITE_NODE = 90,
-    PM_MATCH_LAST_LINE_NODE = 91,
-    PM_MATCH_PREDICATE_NODE = 92,
-    PM_MATCH_REQUIRED_NODE = 93,
-    PM_MATCH_WRITE_NODE = 94,
-    PM_MISSING_NODE = 95,
-    PM_MODULE_NODE = 96,
-    PM_MULTI_TARGET_NODE = 97,
-    PM_MULTI_WRITE_NODE = 98,
-    PM_NEXT_NODE = 99,
-    PM_NIL_NODE = 100,
-    PM_NO_KEYWORDS_PARAMETER_NODE = 101,
-    PM_NUMBERED_REFERENCE_READ_NODE = 102,
-    PM_OPTIONAL_PARAMETER_NODE = 103,
-    PM_OR_NODE = 104,
-    PM_PARAMETERS_NODE = 105,
-    PM_PARENTHESES_NODE = 106,
-    PM_PINNED_EXPRESSION_NODE = 107,
-    PM_PINNED_VARIABLE_NODE = 108,
-    PM_POST_EXECUTION_NODE = 109,
-    PM_PRE_EXECUTION_NODE = 110,
-    PM_PROGRAM_NODE = 111,
-    PM_RANGE_NODE = 112,
-    PM_RATIONAL_NODE = 113,
-    PM_REDO_NODE = 114,
-    PM_REGULAR_EXPRESSION_NODE = 115,
-    PM_REQUIRED_DESTRUCTURED_PARAMETER_NODE = 116,
-    PM_REQUIRED_PARAMETER_NODE = 117,
-    PM_RESCUE_MODIFIER_NODE = 118,
-    PM_RESCUE_NODE = 119,
-    PM_REST_PARAMETER_NODE = 120,
-    PM_RETRY_NODE = 121,
-    PM_RETURN_NODE = 122,
-    PM_SELF_NODE = 123,
-    PM_SINGLETON_CLASS_NODE = 124,
-    PM_SOURCE_ENCODING_NODE = 125,
-    PM_SOURCE_FILE_NODE = 126,
-    PM_SOURCE_LINE_NODE = 127,
-    PM_SPLAT_NODE = 128,
-    PM_STATEMENTS_NODE = 129,
-    PM_STRING_CONCAT_NODE = 130,
-    PM_STRING_NODE = 131,
-    PM_SUPER_NODE = 132,
-    PM_SYMBOL_NODE = 133,
-    PM_TRUE_NODE = 134,
-    PM_UNDEF_NODE = 135,
-    PM_UNLESS_NODE = 136,
-    PM_UNTIL_NODE = 137,
-    PM_WHEN_NODE = 138,
-    PM_WHILE_NODE = 139,
-    PM_X_STRING_NODE = 140,
-    PM_YIELD_NODE = 141,
+    PM_INDEX_AND_WRITE_NODE = 69,
+    PM_INDEX_OPERATOR_WRITE_NODE = 70,
+    PM_INDEX_OR_WRITE_NODE = 71,
+    PM_INSTANCE_VARIABLE_AND_WRITE_NODE = 72,
+    PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE = 73,
+    PM_INSTANCE_VARIABLE_OR_WRITE_NODE = 74,
+    PM_INSTANCE_VARIABLE_READ_NODE = 75,
+    PM_INSTANCE_VARIABLE_TARGET_NODE = 76,
+    PM_INSTANCE_VARIABLE_WRITE_NODE = 77,
+    PM_INTEGER_NODE = 78,
+    PM_INTERPOLATED_MATCH_LAST_LINE_NODE = 79,
+    PM_INTERPOLATED_REGULAR_EXPRESSION_NODE = 80,
+    PM_INTERPOLATED_STRING_NODE = 81,
+    PM_INTERPOLATED_SYMBOL_NODE = 82,
+    PM_INTERPOLATED_X_STRING_NODE = 83,
+    PM_KEYWORD_HASH_NODE = 84,
+    PM_KEYWORD_PARAMETER_NODE = 85,
+    PM_KEYWORD_REST_PARAMETER_NODE = 86,
+    PM_LAMBDA_NODE = 87,
+    PM_LOCAL_VARIABLE_AND_WRITE_NODE = 88,
+    PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE = 89,
+    PM_LOCAL_VARIABLE_OR_WRITE_NODE = 90,
+    PM_LOCAL_VARIABLE_READ_NODE = 91,
+    PM_LOCAL_VARIABLE_TARGET_NODE = 92,
+    PM_LOCAL_VARIABLE_WRITE_NODE = 93,
+    PM_MATCH_LAST_LINE_NODE = 94,
+    PM_MATCH_PREDICATE_NODE = 95,
+    PM_MATCH_REQUIRED_NODE = 96,
+    PM_MATCH_WRITE_NODE = 97,
+    PM_MISSING_NODE = 98,
+    PM_MODULE_NODE = 99,
+    PM_MULTI_TARGET_NODE = 100,
+    PM_MULTI_WRITE_NODE = 101,
+    PM_NEXT_NODE = 102,
+    PM_NIL_NODE = 103,
+    PM_NO_KEYWORDS_PARAMETER_NODE = 104,
+    PM_NUMBERED_REFERENCE_READ_NODE = 105,
+    PM_OPTIONAL_PARAMETER_NODE = 106,
+    PM_OR_NODE = 107,
+    PM_PARAMETERS_NODE = 108,
+    PM_PARENTHESES_NODE = 109,
+    PM_PINNED_EXPRESSION_NODE = 110,
+    PM_PINNED_VARIABLE_NODE = 111,
+    PM_POST_EXECUTION_NODE = 112,
+    PM_PRE_EXECUTION_NODE = 113,
+    PM_PROGRAM_NODE = 114,
+    PM_RANGE_NODE = 115,
+    PM_RATIONAL_NODE = 116,
+    PM_REDO_NODE = 117,
+    PM_REGULAR_EXPRESSION_NODE = 118,
+    PM_REQUIRED_DESTRUCTURED_PARAMETER_NODE = 119,
+    PM_REQUIRED_PARAMETER_NODE = 120,
+    PM_RESCUE_MODIFIER_NODE = 121,
+    PM_RESCUE_NODE = 122,
+    PM_REST_PARAMETER_NODE = 123,
+    PM_RETRY_NODE = 124,
+    PM_RETURN_NODE = 125,
+    PM_SELF_NODE = 126,
+    PM_SINGLETON_CLASS_NODE = 127,
+    PM_SOURCE_ENCODING_NODE = 128,
+    PM_SOURCE_FILE_NODE = 129,
+    PM_SOURCE_LINE_NODE = 130,
+    PM_SPLAT_NODE = 131,
+    PM_STATEMENTS_NODE = 132,
+    PM_STRING_CONCAT_NODE = 133,
+    PM_STRING_NODE = 134,
+    PM_SUPER_NODE = 135,
+    PM_SYMBOL_NODE = 136,
+    PM_TRUE_NODE = 137,
+    PM_UNDEF_NODE = 138,
+    PM_UNLESS_NODE = 139,
+    PM_UNTIL_NODE = 140,
+    PM_WHEN_NODE = 141,
+    PM_WHILE_NODE = 142,
+    PM_X_STRING_NODE = 143,
+    PM_YIELD_NODE = 144,
     PM_SCOPE_NODE
 };
 
@@ -361,7 +364,7 @@ typedef uint16_t pm_node_flags_t;
 #define PM_NODE_FLAG_BITS (sizeof(pm_node_flags_t) * 8)
 static const pm_node_flags_t PM_NODE_FLAG_NEWLINE = (1 << (PM_NODE_FLAG_BITS - 1));
 static const pm_node_flags_t PM_NODE_FLAG_STATIC_LITERAL = (1 << (PM_NODE_FLAG_BITS - 2));
-static const pm_node_flags_t PM_NODE_FLAG_COMMON_MASK = PM_NODE_FLAG_NEWLINE | PM_NODE_FLAG_STATIC_LITERAL;
+static const pm_node_flags_t PM_NODE_FLAG_COMMON_MASK = (1 << (PM_NODE_FLAG_BITS - 1)) | (1 << (PM_NODE_FLAG_BITS - 2));
 
 // For easy access, we define some macros to check node type
 #define PM_NODE_TYPE(node) ((enum pm_node_type)node->type)
@@ -476,6 +479,7 @@ typedef struct pm_assoc_splat_node {
 // Type: PM_BACK_REFERENCE_READ_NODE
 typedef struct pm_back_reference_read_node {
     pm_node_t base;
+    pm_constant_id_t name;
 } pm_back_reference_read_node_t;
 
 // BeginNode
@@ -561,9 +565,6 @@ typedef struct pm_call_and_write_node {
     struct pm_node *receiver;
     pm_location_t call_operator_loc;
     pm_location_t message_loc;
-    pm_location_t opening_loc;
-    struct pm_arguments_node *arguments;
-    pm_location_t closing_loc;
     pm_constant_id_t read_name;
     pm_constant_id_t write_name;
     pm_location_t operator_loc;
@@ -599,9 +600,6 @@ typedef struct pm_call_operator_write_node {
     struct pm_node *receiver;
     pm_location_t call_operator_loc;
     pm_location_t message_loc;
-    pm_location_t opening_loc;
-    struct pm_arguments_node *arguments;
-    pm_location_t closing_loc;
     pm_constant_id_t read_name;
     pm_constant_id_t write_name;
     pm_constant_id_t operator;
@@ -620,9 +618,6 @@ typedef struct pm_call_or_write_node {
     struct pm_node *receiver;
     pm_location_t call_operator_loc;
     pm_location_t message_loc;
-    pm_location_t opening_loc;
-    struct pm_arguments_node *arguments;
-    pm_location_t closing_loc;
     pm_constant_id_t read_name;
     pm_constant_id_t write_name;
     pm_location_t operator_loc;
@@ -1115,6 +1110,61 @@ typedef struct pm_in_node {
     pm_location_t then_loc;
 } pm_in_node_t;
 
+// IndexAndWriteNode
+//
+// Type: PM_INDEX_AND_WRITE_NODE
+// Flags:
+//    PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
+//    PM_CALL_NODE_FLAGS_VARIABLE_CALL
+typedef struct pm_index_and_write_node {
+    pm_node_t base;
+    struct pm_node *receiver;
+    pm_location_t call_operator_loc;
+    pm_location_t opening_loc;
+    struct pm_arguments_node *arguments;
+    pm_location_t closing_loc;
+    struct pm_node *block;
+    pm_location_t operator_loc;
+    struct pm_node *value;
+} pm_index_and_write_node_t;
+
+// IndexOperatorWriteNode
+//
+// Type: PM_INDEX_OPERATOR_WRITE_NODE
+// Flags:
+//    PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
+//    PM_CALL_NODE_FLAGS_VARIABLE_CALL
+typedef struct pm_index_operator_write_node {
+    pm_node_t base;
+    struct pm_node *receiver;
+    pm_location_t call_operator_loc;
+    pm_location_t opening_loc;
+    struct pm_arguments_node *arguments;
+    pm_location_t closing_loc;
+    struct pm_node *block;
+    pm_constant_id_t operator;
+    pm_location_t operator_loc;
+    struct pm_node *value;
+} pm_index_operator_write_node_t;
+
+// IndexOrWriteNode
+//
+// Type: PM_INDEX_OR_WRITE_NODE
+// Flags:
+//    PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
+//    PM_CALL_NODE_FLAGS_VARIABLE_CALL
+typedef struct pm_index_or_write_node {
+    pm_node_t base;
+    struct pm_node *receiver;
+    pm_location_t call_operator_loc;
+    pm_location_t opening_loc;
+    struct pm_arguments_node *arguments;
+    pm_location_t closing_loc;
+    struct pm_node *block;
+    pm_location_t operator_loc;
+    struct pm_node *value;
+} pm_index_or_write_node_t;
+
 // InstanceVariableAndWriteNode
 //
 // Type: PM_INSTANCE_VARIABLE_AND_WRITE_NODE

data/include/prism/diagnostic.h

@@ -158,6 +158,7 @@ typedef enum {
     PM_ERR_NUMBERED_PARAMETER_NOT_ALLOWED,
     PM_ERR_NUMBERED_PARAMETER_OUTER_SCOPE,
     PM_ERR_OPERATOR_MULTI_ASSIGN,
+    PM_ERR_OPERATOR_WRITE_ARGUMENTS,
     PM_ERR_OPERATOR_WRITE_BLOCK,
     PM_ERR_PARAMETER_ASSOC_SPLAT_MULTI,
     PM_ERR_PARAMETER_BLOCK_MULTI,

data/include/prism/node.h

@@ -33,10 +33,17 @@ PRISM_EXPORTED_FUNCTION const char * pm_node_type_to_str(pm_node_type_t node_typ
 // declare them here to avoid generating them.
 typedef struct pm_scope_node {
     pm_node_t base;
+    struct pm_scope_node *previous;
     pm_node_t *ast_node;
     struct pm_parameters_node *parameters;
     pm_node_t *body;
     pm_constant_id_list_t locals;
+    pm_parser_t *parser;
+
+    // We don't have the CRuby types ID and st_table within Prism
+    // so we use void *
+    void *constants; // ID *constants
+    void *index_lookup_table; // st_table *index_lookup_table
 } pm_scope_node_t;
 
 #endif // PRISM_NODE_H

data/include/prism/util/pm_constant_pool.h

@@ -39,9 +39,21 @@ size_t pm_constant_id_list_memsize(pm_constant_id_list_t *list);
 // Free the memory associated with a list of constant ids.
 void pm_constant_id_list_free(pm_constant_id_list_t *list);
 
+// Constant pool buckets can have a couple of different types.
+typedef unsigned int pm_constant_pool_bucket_type_t;
+
+// By default, each constant is a slice of the source.
+static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_DEFAULT = 0;
+
+// An owned constant is one for which memory has been allocated.
+static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_OWNED = 1;
+
+// A constant constant is known at compile time.
+static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_CONSTANT = 2;
+
 typedef struct {
-    unsigned int id: 31;
-    bool owned: 1;
+    unsigned int id: 30;
+    pm_constant_pool_bucket_type_t type: 2;
     uint32_t hash;
 } pm_constant_pool_bucket_t;
 
@@ -63,10 +75,8 @@ typedef struct {
 // Initialize a new constant pool with a given capacity.
 bool pm_constant_pool_init(pm_constant_pool_t *pool, uint32_t capacity);
 
-static inline pm_constant_t* pm_constant_pool_id_to_constant(pm_constant_pool_t *pool, pm_constant_id_t constant_id) {
-    assert(constant_id > 0 && constant_id <= pool->size);
-    return &pool->constants[constant_id - 1];
-}
+// Return a pointer to the constant indicated by the given constant id.
+pm_constant_t * pm_constant_pool_id_to_constant(pm_constant_pool_t *pool, pm_constant_id_t constant_id);
 
 // 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.
@@ -77,6 +87,10 @@ pm_constant_id_t pm_constant_pool_insert_shared(pm_constant_pool_t *pool, const
 // resize fail.
 pm_constant_id_t pm_constant_pool_insert_owned(pm_constant_pool_t *pool, const uint8_t *start, size_t length);
 
+// Insert a constant into a constant pool from memory that is constant. Returns
+// the id of the constant, or 0 if any potential calls to resize fail.
+pm_constant_id_t pm_constant_pool_insert_constant(pm_constant_pool_t *pool, const uint8_t *start, size_t length);
+
 // Free the memory associated with a constant pool.
 void pm_constant_pool_free(pm_constant_pool_t *pool);
 

data/include/prism/version.h

@@ -1,4 +1,4 @@
 #define PRISM_VERSION_MAJOR 0
-#define PRISM_VERSION_MINOR 14
+#define PRISM_VERSION_MINOR 15
 #define PRISM_VERSION_PATCH 0
-#define PRISM_VERSION "0.14.0"
+#define PRISM_VERSION "0.15.0"

data/include/prism.h

@@ -34,7 +34,7 @@ void pm_print_node(pm_parser_t *parser, pm_node_t *node);
 void pm_parser_metadata(pm_parser_t *parser, const char *metadata);
 
 // Generate a scope node from the given node.
-void pm_scope_node_init(pm_node_t *node, pm_scope_node_t *dest);
+void pm_scope_node_init(const pm_node_t *node, pm_scope_node_t *scope, pm_scope_node_t *previous, pm_parser_t *parser);
 
 // The prism version and the serialization format.
 PRISM_EXPORTED_FUNCTION const char * pm_version(void);

data/lib/prism/compiler.rb

@@ -243,6 +243,15 @@ module Prism
     # Compile a InNode node
     alias visit_in_node visit_child_nodes
 
+    # Compile a IndexAndWriteNode node
+    alias visit_index_and_write_node visit_child_nodes
+
+    # Compile a IndexOperatorWriteNode node
+    alias visit_index_operator_write_node visit_child_nodes
+
+    # Compile a IndexOrWriteNode node
+    alias visit_index_or_write_node visit_child_nodes
+
     # Compile a InstanceVariableAndWriteNode node
     alias visit_instance_variable_and_write_node visit_child_nodes
 

data/lib/prism/debug.rb

@@ -45,29 +45,16 @@ module Prism
     # For the given source, compiles with CRuby and returns a list of all of the
     # sets of local variables that were encountered.
     def self.cruby_locals(source)
-      verbose = $VERBOSE
-      $VERBOSE = nil
+      verbose, $VERBOSE = $VERBOSE, nil
 
       begin
         locals = []
         stack = [ISeq.new(RubyVM::InstructionSequence.compile(source).to_a)]
 
         while (iseq = stack.pop)
-          if iseq.type != :once
-            names = iseq.local_table
-
-            # CRuby will push on a special local variable when there are keyword
-            # arguments. We get rid of that here.
-            names = names.grep_v(Integer)
-
-            # For some reason, CRuby occasionally pushes this special local
-            # variable when there are splat arguments. We get rid of that here.
-            names = names.grep_v(:"#arg_rest")
-
-            # Now push them onto the list of locals.
-            locals << names
-          end
-
+          # For some reason, CRuby occasionally pushes this special local
+          # variable when there are splat arguments. We get rid of that here.
+          locals << (iseq.local_table - [:"#arg_rest"])
           iseq.each_child { |child| stack << child }
         end
 
@@ -77,6 +64,8 @@ module Prism
       end
     end
 
+    AnonymousLocal = Object.new
+
     # For the given source, parses with prism and returns a list of all of the
     # sets of local variables that were encountered.
     def self.prism_locals(source)
@@ -97,20 +86,27 @@ module Prism
           # order here so that we can compare properly.
           if params
             sorted = [
-              *params.requireds.grep(RequiredParameterNode).map(&:name),
+              *params.requireds.map do |required|
+                if required.is_a?(RequiredParameterNode)
+                  required.name
+                else
+                  AnonymousLocal
+                end
+              end,
               *params.optionals.map(&:name),
               *((params.rest.name || :*) if params.rest && params.rest.operator != ","),
-              *params.posts.grep(RequiredParameterNode).map(&:name),
+              *params.posts.map do |post|
+                if post.is_a?(RequiredParameterNode)
+                  post.name
+                else
+                  AnonymousLocal
+                end
+              end,
               *params.keywords.reject(&:value).map(&:name),
               *params.keywords.select(&:value).map(&:name)
             ]
 
-            # TODO: When we get a ... parameter, we should be pushing * and &
-            # onto the local list. We don't do that yet, so we need to add them
-            # in here.
-            if params.keyword_rest.is_a?(ForwardingParameterNode)
-              sorted.push(:*, :&, :"...")
-            end
+            sorted << AnonymousLocal if params.keywords.any?
 
             # Recurse down the parameter tree to find any destructured
             # parameters and add them after the other parameters.
@@ -129,11 +125,19 @@ module Prism
             names = sorted.concat(names - sorted)
           end
 
+          names.map!.with_index do |name, index|
+            if name == AnonymousLocal
+              names.length - index + 1
+            else
+              name
+            end
+          end
+
           locals << names
         when ClassNode, ModuleNode, ProgramNode, SingletonClassNode
           locals << node.locals
         when ForNode
-          locals << []
+          locals << [2]
         when PostExecutionNode
           locals.push([], [])
         when InterpolatedRegularExpressionNode

data/lib/prism/dispatcher.rb

@@ -608,6 +608,30 @@ module Prism
       listeners[:on_in_node_leave]&.each { |listener| listener.on_in_node_leave(node) }
     end
 
+    # Dispatch enter and leave events for IndexAndWriteNode nodes and continue
+    # walking the tree.
+    def visit_index_and_write_node(node)
+      listeners[:on_index_and_write_node_enter]&.each { |listener| listener.on_index_and_write_node_enter(node) }
+      super
+      listeners[:on_index_and_write_node_leave]&.each { |listener| listener.on_index_and_write_node_leave(node) }
+    end
+
+    # Dispatch enter and leave events for IndexOperatorWriteNode nodes and continue
+    # walking the tree.
+    def visit_index_operator_write_node(node)
+      listeners[:on_index_operator_write_node_enter]&.each { |listener| listener.on_index_operator_write_node_enter(node) }
+      super
+      listeners[:on_index_operator_write_node_leave]&.each { |listener| listener.on_index_operator_write_node_leave(node) }
+    end
+
+    # Dispatch enter and leave events for IndexOrWriteNode nodes and continue
+    # walking the tree.
+    def visit_index_or_write_node(node)
+      listeners[:on_index_or_write_node_enter]&.each { |listener| listener.on_index_or_write_node_enter(node) }
+      super
+      listeners[:on_index_or_write_node_leave]&.each { |listener| listener.on_index_or_write_node_leave(node) }
+    end
+
     # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes and continue
     # walking the tree.
     def visit_instance_variable_and_write_node(node)
@@ -1607,6 +1631,24 @@ module Prism
         listeners[:on_in_node_leave]&.each { |listener| listener.on_in_node_leave(node) }
       end
 
+      # Dispatch enter and leave events for IndexAndWriteNode nodes.
+      def visit_index_and_write_node(node)
+        listeners[:on_index_and_write_node_enter]&.each { |listener| listener.on_index_and_write_node_enter(node) }
+        listeners[:on_index_and_write_node_leave]&.each { |listener| listener.on_index_and_write_node_leave(node) }
+      end
+
+      # Dispatch enter and leave events for IndexOperatorWriteNode nodes.
+      def visit_index_operator_write_node(node)
+        listeners[:on_index_operator_write_node_enter]&.each { |listener| listener.on_index_operator_write_node_enter(node) }
+        listeners[:on_index_operator_write_node_leave]&.each { |listener| listener.on_index_operator_write_node_leave(node) }
+      end
+
+      # Dispatch enter and leave events for IndexOrWriteNode nodes.
+      def visit_index_or_write_node(node)
+        listeners[:on_index_or_write_node_enter]&.each { |listener| listener.on_index_or_write_node_enter(node) }
+        listeners[:on_index_or_write_node_leave]&.each { |listener| listener.on_index_or_write_node_leave(node) }
+      end
+
       # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes.
       def visit_instance_variable_and_write_node(node)
         listeners[:on_instance_variable_and_write_node_enter]&.each { |listener| listener.on_instance_variable_and_write_node_enter(node) }

data/lib/prism/dsl.rb

@@ -88,8 +88,8 @@ module Prism
     end
 
     # Create a new BackReferenceReadNode node
-    def BackReferenceReadNode(location = Location())
-      BackReferenceReadNode.new(location)
+    def BackReferenceReadNode(name, location = Location())
+      BackReferenceReadNode.new(name, location)
     end
 
     # Create a new BeginNode node
@@ -128,8 +128,8 @@ module Prism
     end
 
     # Create a new CallAndWriteNode node
-    def CallAndWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location = Location())
-      CallAndWriteNode.new(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
+    def CallAndWriteNode(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location = Location())
+      CallAndWriteNode.new(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
     end
 
     # Create a new CallNode node
@@ -138,13 +138,13 @@ module Prism
     end
 
     # Create a new CallOperatorWriteNode node
-    def CallOperatorWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location = Location())
-      CallOperatorWriteNode.new(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location)
+    def CallOperatorWriteNode(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location = Location())
+      CallOperatorWriteNode.new(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location)
     end
 
     # Create a new CallOrWriteNode node
-    def CallOrWriteNode(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location = Location())
-      CallOrWriteNode.new(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
+    def CallOrWriteNode(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location = Location())
+      CallOrWriteNode.new(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
     end
 
     # Create a new CapturePatternNode node
@@ -382,6 +382,21 @@ module Prism
       InNode.new(pattern, statements, in_loc, then_loc, location)
     end
 
+    # Create a new IndexAndWriteNode node
+    def IndexAndWriteNode(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location = Location())
+      IndexAndWriteNode.new(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
+    end
+
+    # Create a new IndexOperatorWriteNode node
+    def IndexOperatorWriteNode(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location = Location())
+      IndexOperatorWriteNode.new(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location)
+    end
+
+    # Create a new IndexOrWriteNode node
+    def IndexOrWriteNode(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location = Location())
+      IndexOrWriteNode.new(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
+    end
+
     # Create a new InstanceVariableAndWriteNode node
     def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())
       InstanceVariableAndWriteNode.new(name, name_loc, operator_loc, value, location)

data/lib/prism/ffi.rb

@@ -25,8 +25,8 @@ module Prism
     #     void         -> :void
     #
     def self.resolve_type(type)
-      type = type.strip.delete_prefix("const ")
-      type.end_with?("*") ? :pointer : type.to_sym
+      type = type.strip
+      type.end_with?("*") ? :pointer : type.delete_prefix("const ").to_sym
     end
 
     # Read through the given header file and find the declaration of each of the