Rename MissingNode to ErrorRecoveryNode

Author: thomasmarshall

config.yml

@@ -812,7 +812,7 @@ nodes:
           - BackReferenceReadNode
           - NumberedReferenceReadNode
           - on error: SymbolNode # alias $a b
-          - on error: MissingNode # alias $a 42
+          - on error: ErrorRecoveryNode # alias $a 42
         comment: |
           Represents the old name of the global variable that can be used before aliasing.
 
@@ -854,7 +854,7 @@ nodes:
           - SymbolNode
           - InterpolatedSymbolNode
           - on error: GlobalVariableReadNode # alias a $b
-          - on error: MissingNode # alias a 42
+          - on error: ErrorRecoveryNode # alias a 42
         comment: |
           Represents the old name of the method that will be aliased.
 
@@ -2466,7 +2466,7 @@ nodes:
         type: node
         kind:
           - SplatNode
-          - on error: MissingNode
+          - on error: ErrorRecoveryNode
         comment: |
           Represents the second wildcard node in the pattern.
 
@@ -2551,7 +2551,7 @@ nodes:
           - MultiTargetNode
           - on error: BackReferenceReadNode # for $& in a end
           - on error: NumberedReferenceReadNode # for $1 in a end
-          - on error: MissingNode # for in 1..10; end
+          - on error: ErrorRecoveryNode # for in 1..10; end
         comment: |
           The index expression for `for` loops.
 
@@ -3686,7 +3686,7 @@ nodes:
 
           /(?<foo>bar)/ =~ baz
           ^^^^^^^^^^^^^^^^^^^^
-  - name: MissingNode
+  - name: ErrorRecoveryNode
     comment: |
       Represents a node that is missing from the source and results in a syntax error.
   - name: ModuleNode
@@ -3700,7 +3700,7 @@ nodes:
         kind:
           - ConstantReadNode
           - ConstantPathNode
-          - on error: MissingNode # module Parent module end
+          - on error: ErrorRecoveryNode # module Parent module end
       - name: body
         type: node?
         kind:
@@ -4140,7 +4140,7 @@ nodes:
           - BackReferenceReadNode # foo in ^$&
           - NumberedReferenceReadNode # foo in ^$1
           - ItLocalVariableReadNode # proc { 1 in ^it }
-          - on error: MissingNode # foo in ^Bar
+          - on error: ErrorRecoveryNode # foo in ^Bar
         comment: |
           The variable used in the pinned expression
 
@@ -4223,7 +4223,7 @@ nodes:
 
               1...foo
                   ^^^
-          If neither right-hand or left-hand side was included, this will be a MissingNode.
+          If neither right-hand or left-hand side was included, this will be an ErrorRecoveryNode.
       - name: operator_loc
         type: location
         comment: |
@@ -4340,7 +4340,7 @@ nodes:
           - IndexTargetNode
           - on error: BackReferenceReadNode # => begin; rescue => $&; end
           - on error: NumberedReferenceReadNode # => begin; rescue => $1; end
-          - on error: MissingNode # begin; rescue =>; end
+          - on error: ErrorRecoveryNode # begin; rescue =>; end
       - name: then_keyword_loc
         type: location?
       - name: statements

lib/prism/node_ext.rb

@@ -208,7 +208,7 @@ def child
       if name
         ConstantReadNode.new(source, -1, name_loc, 0, name)
       else
-        MissingNode.new(source, -1, location, 0)
+        ErrorRecoveryNode.new(source, -1, location, 0)
       end
     end
   end
@@ -249,7 +249,7 @@ def child
       if name
         ConstantReadNode.new(source, -1, name_loc, 0, name)
       else
-        MissingNode.new(source, -1, location, 0)
+        ErrorRecoveryNode.new(source, -1, location, 0)
       end
     end
   end

rakelib/lint.rake

@@ -29,7 +29,7 @@ task :lint do
     exit(1)
   end
 
-  if (uncommented = nodes.select { |node| !%w[MissingNode ProgramNode].include?(node.fetch("name")) && !node.fetch("comment").match?(/^\s{4}/) }).any?
+  if (uncommented = nodes.select { |node| !%w[ErrorRecoveryNode ProgramNode].include?(node.fetch("name")) && !node.fetch("comment").match?(/^\s{4}/) }).any?
     names = uncommented.map { |node| node.fetch("name") }
     warn("Expected all nodes to have an example, missing comments for #{names.join(", ")}")
     exit(1)

sig/prism/node_ext.rbs

@@ -60,18 +60,18 @@ module Prism
     class DynamicPartsInConstantPathError < StandardError
     end
 
-    class MissingNodesInConstantPathError < StandardError
+    class ErrorRecoveryNodesInConstantPathError < StandardError
     end
 
     def full_name_parts: () -> Array[Symbol]
     def full_name: () -> String
-    def child: () -> (ConstantReadNode | MissingNode)
+    def child: () -> (ConstantReadNode | ErrorRecoveryNode)
   end
 
   class ConstantPathTargetNode < Node
     def full_name_parts: () -> Array[Symbol]
     def full_name: () -> String
-    def child: () -> (ConstantReadNode | MissingNode)
+    def child: () -> (ConstantReadNode | ErrorRecoveryNode)
   end
 
   class ConstantTargetNode < Node

src/prism.c

@@ -1958,14 +1958,14 @@ pm_node_alloc(PRISM_ATTRIBUTE_UNUSED pm_parser_t *parser, size_t size) {
 #define PM_NODE_INIT_NODE_TOKEN(parser_, type_, flags_, node_, token_) PM_NODE_INIT(parser_, type_, flags_, PM_NODE_START(node_), PM_TOKEN_END(token_))
 
 /**
- * Allocate a new MissingNode node.
+ * Allocate a new ErrorRecoveryNode node to represent a missing node.
  */
-static pm_missing_node_t *
+static pm_error_recovery_node_t *
 pm_missing_node_create(pm_parser_t *parser, const uint8_t *start, const uint8_t *end) {
-    pm_missing_node_t *node = PM_NODE_ALLOC(parser, pm_missing_node_t);
+    pm_error_recovery_node_t *node = PM_NODE_ALLOC(parser, pm_error_recovery_node_t);
 
-    *node = (pm_missing_node_t) {
-        .base = PM_NODE_INIT(parser, PM_MISSING_NODE, 0, start, end)
+    *node = (pm_error_recovery_node_t) {
+        .base = PM_NODE_INIT(parser, PM_ERROR_RECOVERY_NODE, 0, start, end)
     };
 
     return node;
@@ -3788,7 +3788,7 @@ pm_find_pattern_node_create(pm_parser_t *parser, pm_node_list_t *nodes) {
     }
 
 #if PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS
-    // FindPatternNode#right is typed as SplatNode in this case, so replace the potential MissingNode with a SplatNode.
+    // FindPatternNode#right is typed as SplatNode in this case, so replace the potential ErrorRecoveryNode with a SplatNode.
     // The resulting AST will anyway be ignored, but this file still needs to compile.
     pm_splat_node_t *right_splat_node = PM_NODE_TYPE_P(right, PM_SPLAT_NODE) ? (pm_splat_node_t *) right : left_splat_node;
 #else
@@ -12677,7 +12677,7 @@ parse_unwriteable_target(pm_parser_t *parser, pm_node_t *target) {
 static pm_node_t *
 parse_target(pm_parser_t *parser, pm_node_t *target, bool multiple, bool splat_parent) {
     switch (PM_NODE_TYPE(target)) {
-        case PM_MISSING_NODE:
+        case PM_ERROR_RECOVERY_NODE:
             return target;
         case PM_SOURCE_ENCODING_NODE:
         case PM_FALSE_NODE:
@@ -12867,7 +12867,7 @@ parse_shareable_constant_write(pm_parser_t *parser, pm_node_t *write) {
 static pm_node_t *
 parse_write(pm_parser_t *parser, pm_node_t *target, pm_token_t *operator, pm_node_t *value) {
     switch (PM_NODE_TYPE(target)) {
-        case PM_MISSING_NODE:
+        case PM_ERROR_RECOVERY_NODE:
             pm_node_destroy(parser, value);
             return target;
         case PM_CLASS_VARIABLE_READ_NODE: {
@@ -13220,7 +13220,7 @@ parse_statements(pm_parser_t *parser, pm_context_t context, uint16_t depth) {
         // we were unable to parse an expression, then we will skip past this
         // token and continue parsing the statements list. Otherwise we'll add
         // an error and continue parsing the statements list.
-        if (PM_NODE_TYPE_P(node, PM_MISSING_NODE)) {
+        if (PM_NODE_TYPE_P(node, PM_ERROR_RECOVERY_NODE)) {
             parser_lex(parser);
 
             // If we are at the end of the file, then we need to stop parsing
@@ -13661,7 +13661,7 @@ parse_arguments(pm_parser_t *parser, pm_arguments_t *arguments, bool accepts_for
         parsed_first_argument = true;
 
         // If parsing the argument failed, we need to stop parsing arguments.
-        if (PM_NODE_TYPE_P(argument, PM_MISSING_NODE) || parser->recovering) break;
+        if (PM_NODE_TYPE_P(argument, PM_ERROR_RECOVERY_NODE) || parser->recovering) break;
 
         // If the terminator of these arguments is not EOF, then we have a
         // specific token we're looking for. In that case we can accept a
@@ -16729,7 +16729,7 @@ parse_pattern_primitive(pm_parser_t *parser, pm_constant_id_list_t *captures, pm
             // Call nodes (arithmetic operations) are not allowed in patterns
             if (PM_NODE_TYPE(node) == PM_CALL_NODE) {
                 pm_parser_err_node(parser, node, diag_id);
-                pm_missing_node_t *missing_node = pm_missing_node_create(parser, node->location.start, node->location.end);
+                pm_error_recovery_node_t *missing_node = pm_missing_node_create(parser, node->location.start, node->location.end);
 
                 pm_node_unreference(parser, node);
                 pm_node_destroy(parser, node);
@@ -17521,7 +17521,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                 }
 
                 pm_array_node_elements_append(array, element);
-                if (PM_NODE_TYPE_P(element, PM_MISSING_NODE)) break;
+                if (PM_NODE_TYPE_P(element, PM_ERROR_RECOVERY_NODE)) break;
             }
 
             accept1(parser, PM_TOKEN_NEWLINE);
@@ -17697,7 +17697,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
 
                 // If we couldn't parse an expression at all, then we need to
                 // bail out of the loop.
-                if (PM_NODE_TYPE_P(node, PM_MISSING_NODE)) break;
+                if (PM_NODE_TYPE_P(node, PM_ERROR_RECOVERY_NODE)) break;
 
                 // If we successfully parsed a statement, then we are going to
                 // need terminator to delimit them.
@@ -18248,14 +18248,14 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                             pm_splat_node_t *splat_node = pm_splat_node_create(parser, &operator, expression);
                             pm_when_node_conditions_append(when_node, UP(splat_node));
 
-                            if (PM_NODE_TYPE_P(expression, PM_MISSING_NODE)) break;
+                            if (PM_NODE_TYPE_P(expression, PM_ERROR_RECOVERY_NODE)) break;
                         } else {
                             pm_node_t *condition = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, false, false, PM_ERR_CASE_EXPRESSION_AFTER_WHEN, (uint16_t) (depth + 1));
                             pm_when_node_conditions_append(when_node, condition);
 
                             // If we found a missing node, then this is a syntax
                             // error and we should stop looping.
-                            if (PM_NODE_TYPE_P(condition, PM_MISSING_NODE)) break;
+                            if (PM_NODE_TYPE_P(condition, PM_ERROR_RECOVERY_NODE)) break;
 
                             // If this is a string node, then we need to mark it
                             // as frozen because when clause strings are frozen.
@@ -19134,7 +19134,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             pm_undef_node_t *undef = pm_undef_node_create(parser, &parser->previous);
             pm_node_t *name = parse_undef_argument(parser, (uint16_t) (depth + 1));
 
-            if (PM_NODE_TYPE_P(name, PM_MISSING_NODE)) {
+            if (PM_NODE_TYPE_P(name, PM_ERROR_RECOVERY_NODE)) {
                 pm_node_destroy(parser, name);
             } else {
                 pm_undef_node_append(undef, name);
@@ -19144,7 +19144,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                     parser_lex(parser);
                     name = parse_undef_argument(parser, (uint16_t) (depth + 1));
 
-                    if (PM_NODE_TYPE_P(name, PM_MISSING_NODE)) {
+                    if (PM_NODE_TYPE_P(name, PM_ERROR_RECOVERY_NODE)) {
                         pm_node_destroy(parser, name);
                         break;
                     }
@@ -19218,7 +19218,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
 
             // If we can recover from a syntax error that occurred while parsing
             // the name of the module, then we'll handle that here.
-            if (PM_NODE_TYPE_P(constant_path, PM_MISSING_NODE)) {
+            if (PM_NODE_TYPE_P(constant_path, PM_ERROR_RECOVERY_NODE)) {
                 pop_block_exits(parser, previous_block_exits);
                 pm_node_list_free(&current_block_exits);
 
@@ -20291,7 +20291,7 @@ parse_assignment_values(pm_parser_t *parser, pm_binding_power_t previous_binding
             pm_node_t *element = parse_starred_expression(parser, binding_power, false, PM_ERR_ARRAY_ELEMENT, (uint16_t) (depth + 1));
 
             pm_array_node_elements_append(array, element);
-            if (PM_NODE_TYPE_P(element, PM_MISSING_NODE)) break;
+            if (PM_NODE_TYPE_P(element, PM_ERROR_RECOVERY_NODE)) break;
 
             parse_assignment_value_local(parser, element);
         }
@@ -21584,7 +21584,7 @@ parse_expression(pm_parser_t *parser, pm_binding_power_t binding_power, bool acc
     pm_node_t *node = parse_expression_prefix(parser, binding_power, accepts_command_call, accepts_label, diag_id, depth);
 
     switch (PM_NODE_TYPE(node)) {
-        case PM_MISSING_NODE:
+        case PM_ERROR_RECOVERY_NODE:
             // If we found a syntax error, then the type of node returned by
             // parse_expression_prefix is going to be a missing node.
             return node;

templates/lib/prism/dsl.rb.erb

@@ -127,7 +127,7 @@ module Prism
     # The default node that gets attached to nodes if no node is specified for a
     # required node field.
     def default_node(source, location)
-      MissingNode.new(source, -1, location, 0)
+      ErrorRecoveryNode.new(source, -1, location, 0)
     end
   end
 end

test/prism/result/error_recovery_test.rb

@@ -17,7 +17,7 @@ def test_alias_global_variable_node_old_name_missing
       refute result.success?
 
       node = result.value.statements.body.first
-      assert_kind_of MissingNode, node.old_name
+      assert_kind_of ErrorRecoveryNode, node.old_name
     end
 
     def test_alias_method_node_old_name_global_variable
@@ -33,7 +33,7 @@ def test_alias_method_node_old_name_missing
       refute result.success?
 
       node = result.value.statements.body.first
-      assert_kind_of MissingNode, node.old_name
+      assert_kind_of ErrorRecoveryNode, node.old_name
     end
 
     def test_class_node_constant_path_call
@@ -65,7 +65,7 @@ def test_for_node_index_missing
       refute result.success?
 
       node = result.value.statements.body.first
-      assert_kind_of MissingNode, node.index
+      assert_kind_of ErrorRecoveryNode, node.index
     end
 
     def test_interpolated_string_node_parts_xstring
@@ -89,7 +89,7 @@ def test_module_node_constant_path_missing
       refute result.success?
 
       node = result.value.statements.body.first.body.body.first
-      assert_kind_of MissingNode, node.constant_path
+      assert_kind_of ErrorRecoveryNode, node.constant_path
     end
 
     def test_multi_target_node_lefts_back_reference
@@ -185,7 +185,7 @@ def test_pinned_variable_node_variable_missing
       refute result.success?
 
       node = result.value.statements.body.first.pattern
-      assert_kind_of MissingNode, node.variable
+      assert_kind_of ErrorRecoveryNode, node.variable
     end
 
     def test_rescue_node_reference_back_reference
@@ -209,7 +209,7 @@ def test_rescue_node_reference_missing
       refute result.success?
 
       node = result.value.statements.body.first.rescue_clause
-      assert_kind_of MissingNode, node.reference
+      assert_kind_of ErrorRecoveryNode, node.reference
     end
   end
 end

test/prism/result/source_location_test.rb

@@ -920,7 +920,7 @@ def test_YieldNode
     end
 
     def test_all_tested
-      expected = Prism.constants.grep(/.Node$/).sort - %i[MissingNode ProgramNode]
+      expected = Prism.constants.grep(/.Node$/).sort - %i[ErrorRecoveryNode ProgramNode]
       actual = SourceLocationTest.instance_methods(false).grep(/.Node$/).map { |name| name[5..].to_sym }.sort
       assert_equal expected, actual
     end