Translate constant reads/writes

Author: amomchilov

ast/desugar/Desugar.cc

@@ -731,6 +731,8 @@ ExpressionPtr node2TreeImpl(DesugarContext dctx, unique_ptr<parser::Node> what)
             // add entries here, without consulting the "node.*" counters from a
             // run over a representative code base.
             [&](parser::Const *const_) {
+                TRANSLATED_BY_PRISM(dctx, const_);
+
                 auto scope = node2TreeImpl(dctx, std::move(const_->scope));
                 ExpressionPtr res = MK::UnresolvedConstant(loc, std::move(scope), const_->name);
                 result = std::move(res);
@@ -1586,11 +1588,15 @@ ExpressionPtr node2TreeImpl(DesugarContext dctx, unique_ptr<parser::Node> what)
                 result = std::move(res);
             },
             [&](parser::ConstLhs *constLhs) {
+                TRANSLATED_BY_PRISM(dctx, constLhs);
+
                 auto scope = node2TreeImpl(dctx, std::move(constLhs->scope));
                 ExpressionPtr res = MK::UnresolvedConstant(loc, std::move(scope), constLhs->name);
                 result = std::move(res);
             },
             [&](parser::Cbase *cbase) {
+                TRANSLATED_BY_PRISM(dctx, cbase);
+
                 ExpressionPtr res = MK::Constant(loc, core::Symbols::root());
                 result = std::move(res);
             },

parser/prism/Translator.cc

@@ -1886,6 +1886,7 @@ unique_ptr<parser::Node> Translator::translateConst(PrismLhsNode *node, bool rep
     // It's important that in all branches `enterNameUTF8` is called, which `translateConstantName` does,
     // so that the name is available for the rest of the pipeline.
     auto name = translateConstantName(node->name);
+    auto sorbetName = gs.enterNameConstant(name);
 
     if (isInMethodDef && replaceWithDynamicConstAssign) {
         // Check if this is a dynamic constant assignment (SyntaxError at runtime)
@@ -1899,6 +1900,8 @@ unique_ptr<parser::Node> Translator::translateConst(PrismLhsNode *node, bool rep
                                     is_same_v<PrismLhsNode, pm_constant_path_node>;
 
     std::unique_ptr<parser::Node> parent;
+    ast::ExpressionPtr parentExpr;
+
     if constexpr (isConstantPath) { // Handle constant paths, has a parent node that needs translation.
         if (auto prismParentNode = node->parent; prismParentNode != nullptr) {
             // This constant reference is chained onto another constant reference.
@@ -1909,9 +1912,12 @@ unique_ptr<parser::Node> Translator::translateConst(PrismLhsNode *node, bool rep
             //  /  \
             // A   ::B
             parent = translate(prismParentNode);
+            parentExpr = parent ? parent->getCachedDesugaredExpr() : nullptr;
         } else { // This is the root of a fully qualified constant reference, like `::A`.
             auto delimiterLoc = translateLoc(node->delimiter_loc); // The location of the `::`
+
             parent = make_node<parser::Cbase>(delimiterLoc);
+            parentExpr = MK::Constant(delimiterLoc, core::Symbols::root());
         }
     } else { // Handle plain constants like `A`, that aren't part of a constant path.
         static_assert(
@@ -1928,9 +1934,16 @@ unique_ptr<parser::Node> Translator::translateConst(PrismLhsNode *node, bool rep
             location = translateLoc(node->name_loc);
         }
         parent = nullptr;
+        parentExpr = MK::EmptyTree();
+    }
+
+    auto sorbetNode = make_node<SorbetLHSNode>(location, move(parent), sorbetName);
+
+    if (parentExpr != nullptr) {
+        sorbetNode->cacheDesugaredExpr(MK::UnresolvedConstant(location, move(parentExpr), sorbetName));
     }
 
-    return make_node<SorbetLHSNode>(location, move(parent), gs.enterNameConstant(name));
+    return sorbetNode;
 }
 
 core::NameRef Translator::translateConstantName(pm_constant_id_t constant_id) {