Resolve anonymous arg crash

Author: KaanOzkan

parser/prism/Factory.cc

@@ -182,6 +182,9 @@ pm_call_node_t *Factory::createCallNode(pm_node_t *receiver, pm_constant_id_t me
 }
 
 pm_node_t *Factory::SymbolFromConstant(core::LocOffsets nameLoc, pm_constant_id_t nameId) const {
+    ENFORCE(nameId != PM_CONSTANT_ID_UNSET,
+            "SymbolFromConstant called with PM_CONSTANT_ID_UNSET (anonymous parameter name). "
+            "Caller must check for PM_CONSTANT_ID_UNSET before calling.");
     auto nameView = parser.resolveConstant(nameId);
 
     pm_symbol_node_t *symbolNode = allocateNode<pm_symbol_node_t>();

parser/prism/Parser.cc

@@ -46,6 +46,9 @@ core::LocOffsets Parser::translateLocation(const uint8_t *start, const uint8_t *
 }
 
 string_view Parser::resolveConstant(pm_constant_id_t constantId) const {
+    ENFORCE(constantId != PM_CONSTANT_ID_UNSET,
+            "resolveConstant called with PM_CONSTANT_ID_UNSET (anonymous parameter name). "
+            "Caller must check for PM_CONSTANT_ID_UNSET before calling.");
     pm_constant_t *constant = pm_constant_pool_id_to_constant(&parser.constant_pool, constantId);
 
     return cast_prism_string(constant->start, constant->length);

parser/prism/Translator.cc

@@ -2840,7 +2840,7 @@ unique_ptr<parser::Node> Translator::translate(pm_node_t *node, bool preserveCon
                 constexpr uint32_t length = "**"sv.size();
                 kwrestLoc = core::LocOffsets{location.beginPos() + length, location.endPos()};
             } else { // An anonymous keyword rest parameter, like `def foo(**)`
-                sorbetName = nextUniqueParserName(core::Names::starStar());
+                sorbetName = core::Names::starStar();
 
                 // This location *does* include the whole `**`.
                 kwrestLoc = location;
@@ -4208,7 +4208,7 @@ Translator::translateParametersNode(pm_parameters_node *paramsNode, core::LocOff
             constexpr uint32_t length = "&"sv.size();
             blockParamLoc = core::LocOffsets{blockParamLoc.beginPos() + length, blockParamLoc.endPos()};
         } else { // An anonymous block parameter, like `def foo(&)`
-            enclosingBlockParamName = nextUniqueParserName(core::Names::ampersand());
+            enclosingBlockParamName = core::Names::ampersand();
         }
 
         auto blockParamExpr = MK::BlockParam(blockParamLoc, MK::Local(blockParamLoc, enclosingBlockParamName));

rbs/prism/AssertionsRewriterPrism.cc

@@ -63,7 +63,6 @@ vector<pair<core::LocOffsets, core::NameRef>>
 extractTypeParamsPrism(core::MutableContext ctx, const parser::Prism::Parser &parser, pm_node_t *block) {
     vector<pair<core::LocOffsets, core::NameRef>> typeParams;
 
-    // Do we have a block?
     if (!block || !PM_NODE_TYPE_P(block, PM_BLOCK_NODE)) {
         return typeParams;
     }

rbs/prism/MethodTypeToParserNodePrism.cc

@@ -201,6 +201,21 @@ string_view nodeKindToString(const pm_node_t *node) {
     }
 }
 
+// Get the NameRef for an anonymous parameter node
+core::NameRef anonymousParamName(core::MutableContext ctx, const pm_node_t *node) {
+    switch (PM_NODE_TYPE(node)) {
+        case PM_REST_PARAMETER_NODE:
+            return core::Names::star();
+        case PM_KEYWORD_REST_PARAMETER_NODE:
+            return core::Names::starStar();
+        case PM_BLOCK_PARAMETER_NODE:
+            return core::Names::ampersand();
+        default:
+            ENFORCE(false, "Unexpected anonymous parameter node type");
+            return core::NameRef::noName();
+    }
+}
+
 optional<core::AutocorrectSuggestion> autocorrectArg(core::MutableContext ctx, pm_node_t *methodArg, RBSArg arg,
                                                      const parser::Prism::Parser &prismParser,
                                                      const RBSDeclaration &declaration) {
@@ -624,7 +639,13 @@ pm_node_t *MethodTypeToParserNodePrism::methodSignature(pm_node_t *methodDef, co
         pm_node_t *methodParam = methodParams[i];
         if (!checkParameterKindMatch(arg, methodParam)) {
             if (auto e = ctx.beginIndexerError(arg.loc, core::errors::Rewriter::RBSIncorrectParameterKind)) {
-                auto methodParamNameStr = prismParser.resolveConstant(getParamName(methodParams[i]));
+                auto paramNameId = getParamName(methodParams[i]);
+                string_view methodParamNameStr;
+                if (paramNameId != PM_CONSTANT_ID_UNSET) {
+                    methodParamNameStr = prismParser.resolveConstant(paramNameId);
+                } else {
+                    methodParamNameStr = anonymousParamName(ctx, methodParam).shortName(ctx.state);
+                }
                 e.setHeader("Argument kind mismatch for `{}`, method declares `{}`, but RBS signature declares `{}`",
                             methodParamNameStr, nodeKindToString(methodParam), argKindToString(arg.kind));
 
@@ -641,11 +662,12 @@ pm_node_t *MethodTypeToParserNodePrism::methodSignature(pm_node_t *methodDef, co
             auto *methodParam = methodParams[i];
             auto methodParamName = getParamName(methodParam);
 
-            // Special case: anonymous block parameter (&) should use symbol :&
-            if (arg.kind == RBSArg::Kind::Block && methodParamName == PM_CONSTANT_ID_UNSET) {
-                symbolNode = prism.Symbol(tinyLocOffsets, "&"sv);
-            } else {
+            if (methodParamName != PM_CONSTANT_ID_UNSET) {
                 symbolNode = prism.SymbolFromConstant(tinyLocOffsets, methodParamName);
+            } else {
+                // Anonymous parameter - use the canonical name (*, **, &)
+                auto name = anonymousParamName(ctx, methodParam);
+                symbolNode = prism.Symbol(tinyLocOffsets, name.shortName(ctx.state));
             }
         }