translateConst use expr_only and narrow return

Author: jesse-shopify

parser/prism/Translator.cc

@@ -75,11 +75,11 @@ class ExprOnly final : public Node {
     }
 };
 
-unique_ptr<parser::Node> expr_only(ast::ExpressionPtr expr) {
+unique_ptr<ExprOnly> expr_only(ast::ExpressionPtr expr) {
     return make_unique<ExprOnly>(move(expr), expr.loc());
 }
 
-unique_ptr<parser::Node> expr_only(ast::ExpressionPtr expr, core::LocOffsets loc) {
+unique_ptr<ExprOnly> expr_only(ast::ExpressionPtr expr, core::LocOffsets loc) {
     return make_unique<ExprOnly>(move(expr), loc);
 }
 
@@ -5476,15 +5476,15 @@ ast::ExpressionPtr Translator::desugarStatements(pm_statements_node *stmtsNode,
 // Usually returns the `SorbetLHSNode`, but for constant writes and targets,
 // it can can return an `LVarLhs` as a workaround in the case of a dynamic constant assignment.
 template <typename PrismLhsNode, typename SorbetLHSNode, bool checkForDynamicConstAssign>
-unique_ptr<parser::Node> Translator::translateConst(PrismLhsNode *node) {
+unique_ptr<ExprOnly> Translator::translateConst(PrismLhsNode *node) {
     static_assert(is_same_v<SorbetLHSNode, parser::Const> || is_same_v<SorbetLHSNode, parser::ConstLhs>,
                   "Invalid LHS type. Must be one of `parser::Const` or `parser::ConstLhs`.");
 
     // Constant name might be unset, e.g. `::`.
     if (node->name == PM_CONSTANT_ID_UNSET) {
         auto location = translateLoc(node->base.location);
         auto expr = MK::UnresolvedConstant(location, MK::EmptyTree(), core::Names::empty());
-        return make_node_with_expr<SorbetLHSNode>(move(expr), location, nullptr, core::Names::empty());
+        return expr_only(move(expr));
     }
 
     // It's important that in all branches `enterNameUTF8` is called, which `translateConstantName` does,
@@ -5509,7 +5509,7 @@ unique_ptr<parser::Node> Translator::translateConst(PrismLhsNode *node) {
             // This is a copy of a workaround from `Desugar.cc`, which substitues in a fake assignment,
             // so the parsing can continue. See other usages of `dynamicConstAssign` for more details.
             auto expr = MK::Local(location, core::Names::dynamicConstAssign());
-            return make_node_with_expr<LVarLhs>(move(expr), location, core::Names::dynamicConstAssign());
+            return expr_only(move(expr));
         }
     }
 
@@ -5563,7 +5563,7 @@ unique_ptr<parser::Node> Translator::translateConst(PrismLhsNode *node) {
     }
 
     ast::ExpressionPtr desugaredExpr = MK::UnresolvedConstant(location, move(parentExpr), constantName);
-    return make_node_with_expr<SorbetLHSNode>(move(desugaredExpr), location, move(parent), constantName);
+    return expr_only(move(desugaredExpr));
 }
 
 core::NameRef Translator::translateConstantName(pm_constant_id_t constant_id) {

parser/prism/Translator.h

@@ -17,6 +17,8 @@ namespace sorbet::parser::Prism {
 // Used by the desugar*OpAssign functions to determine the appropriate desugaring strategy.
 enum class OpAssignKind { And, Or, Operator };
 
+class ExprOnly;
+
 class Translator final {
     const Parser &parser;
     // This context holds a reference to the GlobalState allocated up the call stack, which is why we don't allow
@@ -163,7 +165,7 @@ class Translator final {
                                                            std::unique_ptr<parser::Node> rhs);
 
     template <typename PrismLhsNode, typename SorbetLHSNode, bool checkForDynamicConstAssign = false>
-    std::unique_ptr<parser::Node> translateConst(PrismLhsNode *node);
+    std::unique_ptr<ExprOnly> translateConst(PrismLhsNode *node);
     core::NameRef translateConstantName(pm_constant_id_t constantId);
 
     // Generates a unique name for a `parser::Node`.