Use static names for anonymous parameters

The original RBS rewriter runs after the parser has assigned unique
names to anonymous parameters, which it can then pull out of the method
definition. With the Prism RBS rewriter, we can't generate unique names
until later on when the translator is run. We can use static names
instead as `*`, `**`, and `&` are guaranteed to be unique anyway (in
fact this is already the case for the block param).

Author: thomasmarshall

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));
@@ -5408,10 +5408,6 @@ core::NameRef Translator::translateConstantName(pm_constant_id_t constant_id) {
     return ctx.state.enterNameUTF8(parser.resolveConstant(constant_id));
 }
 
-core::NameRef Translator::nextUniqueParserName(core::NameRef original) {
-    return ctx.state.freshNameUnique(core::UniqueNameKind::Parser, original, ++parserUniqueCounter);
-}
-
 core::NameRef Translator::nextUniqueDesugarName(core::NameRef original) {
     ENFORCE(directlyDesugar, "This shouldn't be called if we're not directly desugaring.");
     return ctx.state.freshNameUnique(core::UniqueNameKind::Desugar, original, ++desugarUniqueCounter);

parser/prism/Translator.h

@@ -168,9 +168,6 @@ class Translator final {
     std::unique_ptr<parser::Node> translateConst(PrismLhsNode *node);
     core::NameRef translateConstantName(pm_constant_id_t constantId);
 
-    // Generates a unique name for a `parser::Node`.
-    core::NameRef nextUniqueParserName(core::NameRef original);
-
     // Generates a unique name for a directly desugared `ast::ExpressionPtr`.
     core::NameRef nextUniqueDesugarName(core::NameRef original);
 

rbs/prism/MethodTypeToParserNodePrism.cc

@@ -702,10 +702,21 @@ pm_node_t *MethodTypeToParserNodePrism::methodSignature(const pm_node_t *methodD
             if (!methodArgs.empty() && paramIndex < methodArgs.size()) {
                 auto methodArg = methodArgs[paramIndex];
 
-                // Special case: anonymous block parameter (&) should use symbol :&
-                if (arg.kind == RBSArg::Kind::Block && methodArg.nameId == PM_CONSTANT_ID_UNSET) {
-                    symbolNode = prism.Symbol(tinyLocOffsets, "&"sv);
-                } else if (methodArg.nameId != PM_CONSTANT_ID_UNSET) {
+                if (methodArg.nameId == PM_CONSTANT_ID_UNSET) {
+                    switch (arg.kind) {
+                        case RBSArg::Kind::RestKeyword:
+                            symbolNode = prism.Symbol(tinyLocOffsets, "**"sv);
+                            break;
+                        case RBSArg::Kind::RestPositional:
+                            symbolNode = prism.Symbol(tinyLocOffsets, "*"sv);
+                            break;
+                        case RBSArg::Kind::Block:
+                            symbolNode = prism.Symbol(tinyLocOffsets, "&"sv);
+                            break;
+                        default:
+                            break;
+                    }
+                } else {
                     symbolNode = prism.SymbolFromConstant(tinyLocOffsets, methodArg.nameId);
                 }
             }