[PRISM] [Feature #19979] Method definition with &nil

nobu · paracycle · commit b1b9bbdb011b · 2026-02-15T18:54:38.000+02:00
diff --git a/lib/prism/node_ext.rb b/lib/prism/node_ext.rb
@@ -316,7 +316,13 @@ def signature
         names << [:nokey]
       end
 
-      names << [:block, block.name || :&] if block
+      case block
+      when BlockParameterNode
+        names << [:block, block.name || :&]
+      when NoBlockParameterNode
+        names << [:noblock]
+      end
+
       names
     end
   end
diff --git a/prism/config.yml b/prism/config.yml
@@ -3919,6 +3919,18 @@ nodes:
 
           nil
           ^^^
+  - name: NoBlockParameterNode
+    fields:
+      - name: operator_loc
+        type: location
+      - name: keyword_loc
+        type: location
+    comment: |
+      Represents the use of `&nil` inside method arguments.
+
+          def a(&nil)
+                ^^^^
+          end
   - name: NoKeywordsParameterNode
     fields:
       - name: operator_loc
@@ -4065,7 +4077,9 @@ nodes:
           - NoKeywordsParameterNode
       - name: block
         type: node?
-        kind: BlockParameterNode
+        kind:
+          - BlockParameterNode
+          - NoBlockParameterNode
     comment: |
       Represents the list of parameters on a method, block, or lambda definition.
 
diff --git a/prism/prism.c b/prism/prism.c
@@ -5558,6 +5558,24 @@ pm_nil_node_create(pm_parser_t *parser, const pm_token_t *token) {
     return node;
 }
 
+/**
+ * Allocate and initialize a new NoKeywordsParameterNode node.
+ */
+static pm_no_block_parameter_node_t *
+pm_no_block_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *keyword) {
+    assert(operator->type == PM_TOKEN_AMPERSAND || operator->type == PM_TOKEN_UAMPERSAND);
+    assert(keyword->type == PM_TOKEN_KEYWORD_NIL);
+    pm_no_block_parameter_node_t *node = PM_NODE_ALLOC(parser, pm_no_block_parameter_node_t);
+
+    *node = (pm_no_block_parameter_node_t) {
+        .base = PM_NODE_INIT(parser, PM_NO_BLOCK_PARAMETER_NODE, 0, PM_LOCATION_INIT_TOKENS(parser, operator, keyword)),
+        .operator_loc = TOK2LOC(parser, operator),
+        .keyword_loc = TOK2LOC(parser, keyword)
+    };
+
+    return node;
+}
+
 /**
  * Allocate and initialize a new NoKeywordsParameterNode node.
  */
@@ -5787,9 +5805,9 @@ pm_parameters_node_keyword_rest_set(pm_parameters_node_t *params, pm_node_t *par
  * Set the block parameter on a ParametersNode node.
  */
 static void
-pm_parameters_node_block_set(pm_parameters_node_t *params, pm_block_parameter_node_t *param) {
+pm_parameters_node_block_set(pm_parameters_node_t *params, pm_node_t *param) {
     assert(params->block == NULL);
-    pm_parameters_node_location_set(params, UP(param));
+    pm_parameters_node_location_set(params, param);
     params->block = param;
 }
 
@@ -13915,26 +13933,33 @@ parse_parameters(
                 parser_lex(parser);
 
                 pm_token_t operator = parser->previous;
-                pm_token_t name = { 0 };
+                pm_node_t *param;
 
-                bool repeated = false;
-                if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
-                    name = parser->previous;
-                    repeated = pm_parser_parameter_name_check(parser, &name);
-                    pm_parser_local_add_token(parser, &name, 1);
+                if (accept1(parser, PM_TOKEN_KEYWORD_NIL)) {
+                    param = (pm_node_t *) pm_no_block_parameter_node_create(parser, &operator, &parser->previous);
                 } else {
-                    parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_BLOCK;
-                }
+                    pm_token_t name = {0};
 
-                pm_block_parameter_node_t *param = pm_block_parameter_node_create(parser, NTOK2PTR(name), &operator);
-                if (repeated) {
-                    pm_node_flag_set_repeated_parameter(UP(param));
+                    bool repeated = false;
+                    if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
+                        name = parser->previous;
+                        repeated = pm_parser_parameter_name_check(parser, &name);
+                        pm_parser_local_add_token(parser, &name, 1);
+                    } else {
+                        parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_BLOCK;
+                    }
+
+                    param = (pm_node_t *) pm_block_parameter_node_create(parser, NTOK2PTR(name), &operator);
+                    if (repeated) {
+                        pm_node_flag_set_repeated_parameter(param);
+                    }
                 }
+
                 if (params->block == NULL) {
                     pm_parameters_node_block_set(params, param);
                 } else {
-                    pm_parser_err_node(parser, UP(param), PM_ERR_PARAMETER_BLOCK_MULTI);
-                    pm_parameters_node_posts_append(params, UP(param));
+                    pm_parser_err_node(parser, param, PM_ERR_PARAMETER_BLOCK_MULTI);
+                    pm_parameters_node_posts_append(params, param);
                 }
 
                 break;
diff --git a/prism_compile.c b/prism_compile.c
@@ -4521,6 +4521,7 @@ pm_compile_defined_expr0(rb_iseq_t *iseq, const pm_node_t *node, const pm_node_l
       case PM_PARAMETERS_NODE:
       case PM_KEYWORD_REST_PARAMETER_NODE:
       case PM_NO_KEYWORDS_PARAMETER_NODE:
+      case PM_NO_BLOCK_PARAMETER_NODE:
       case PM_NUMBERED_PARAMETERS_NODE:
       case PM_OPTIONAL_KEYWORD_PARAMETER_NODE:
       case PM_OPTIONAL_PARAMETER_NODE:
@@ -6337,7 +6338,7 @@ pm_compile_scope_node(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_nod
         }
     }
 
-    if (parameters_node && parameters_node->block) {
+    if (parameters_node && parameters_node->block && PM_NODE_TYPE_P(parameters_node->block, PM_BLOCK_PARAMETER_NODE)) {
         const pm_block_parameter_node_t *block_node = (const pm_block_parameter_node_t *) parameters_node->block;
 
         if (PM_NODE_FLAG_P(block_node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER) || !block_node->name) {
@@ -6683,26 +6684,38 @@ pm_compile_scope_node(rb_iseq_t *iseq, pm_scope_node_t *scope_node, const pm_nod
         // def foo(a, (b, *c, d), e = 1, *f, g, (h, *i, j), k:, l: 1, **m, &n)
         //                                                                  ^^
         if (parameters_node->block) {
-            body->param.block_start = local_index;
-            body->param.flags.has_block = true;
-            iseq_set_use_block(iseq);
+            switch (PM_NODE_TYPE(parameters_node->block)) {
+              case PM_BLOCK_PARAMETER_NODE: {
+                body->param.block_start = local_index;
+                body->param.flags.has_block = true;
 
-            pm_constant_id_t name = ((const pm_block_parameter_node_t *) parameters_node->block)->name;
+                iseq_set_use_block(iseq);
 
-            if (name) {
-                if (PM_NODE_FLAG_P(parameters_node->block, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
-                    ID local = pm_constant_id_lookup(scope_node, name);
-                    local_table_for_iseq->ids[local_index] = local;
+                pm_constant_id_t name = ((const pm_block_parameter_node_t *) parameters_node->block)->name;
+
+                if (name) {
+                    if (PM_NODE_FLAG_P(parameters_node->block, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
+                        ID local = pm_constant_id_lookup(scope_node, name);
+                        local_table_for_iseq->ids[local_index] = local;
+                    }
+                    else {
+                        pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
+                    }
                 }
                 else {
-                    pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
+                    pm_insert_local_special(idAnd, local_index, index_lookup_table, local_table_for_iseq);
                 }
-            }
-            else {
-                pm_insert_local_special(idAnd, local_index, index_lookup_table, local_table_for_iseq);
-            }
 
-            local_index++;
+                local_index++;
+                break;
+              }
+              case PM_NO_BLOCK_PARAMETER_NODE: {
+                body->param.flags.accepts_no_block = true;
+                break;
+              }
+              default:
+                rb_bug("node type %s not expected as block parameter", pm_node_type_to_str(PM_NODE_TYPE(parameters_node->block)));
+            }
         }
     }
 
@@ -9952,6 +9965,12 @@ pm_compile_node(rb_iseq_t *iseq, const pm_node_t *node, LINK_ANCHOR *const ret,
 
         return;
       }
+      case PM_NO_BLOCK_PARAMETER_NODE: {
+        // def foo(&nil); end
+        //         ^^^^
+        ISEQ_BODY(iseq)->param.flags.accepts_no_block = TRUE;
+        return;
+      }
       case PM_NO_KEYWORDS_PARAMETER_NODE: {
         // def foo(**nil); end
         //         ^^^^^
diff --git a/test/prism/result/source_location_test.rb b/test/prism/result/source_location_test.rb
@@ -650,6 +650,10 @@ def test_NilNode
       assert_location(NilNode, "nil")
     end
 
+    def test_NoBlockParameterNode
+      assert_location(NoBlockParameterNode, "def foo(&nil); end", 8...12) { |node| node.parameters.block }
+    end
+
     def test_NoKeywordsParameterNode
       assert_location(NoKeywordsParameterNode, "def foo(**nil); end", 8...13) { |node| node.parameters.keyword_rest }
     end
diff --git a/test/prism/ruby/parameters_signature_test.rb b/test/prism/ruby/parameters_signature_test.rb
@@ -50,6 +50,10 @@ def test_nokey
       assert_parameters([[:nokey]], "**nil")
     end
 
+    def test_noblock
+      assert_parameters([[:noblock]], "&nil")
+    end
+
     def test_keyrest_anonymous
       assert_parameters([[:keyrest, :**]], "**")
     end
