Add desugarNullable() helper

Author: amomchilov

parser/prism/Translator.cc

@@ -1001,6 +1001,19 @@ pair<core::LocOffsets, core::LocOffsets> Translator::computeSendLoc(PrismNode *c
 ast::ExpressionPtr Translator::desugar(pm_node_t *node, bool preserveConcreteSyntax) {
     auto legacyNode = translate(node, preserveConcreteSyntax);
 
+    ENFORCE(legacyNode != nullptr);
+    enforceHasExpr(legacyNode);
+
+    return legacyNode->takeDesugaredExpr();
+}
+
+ast::ExpressionPtr Translator::desugarNullable(pm_node_t *node, bool preserveConcreteSyntax) {
+    auto legacyNode = translate(node, preserveConcreteSyntax);
+
+    if (legacyNode == nullptr) {
+        return MK::EmptyTree();
+    }
+
     enforceHasExpr(legacyNode);
 
     return legacyNode->takeDesugaredExpr();
@@ -2524,13 +2537,9 @@ unique_ptr<parser::Node> Translator::translate(pm_node_t *node, bool preserveCon
         case PM_IF_NODE: { // An `if` statement or modifier, like `if cond; ...; end` or `a.b if cond`
             auto ifNode = down_cast<pm_if_node>(node);
 
-            auto predicatePreExpr = translate(ifNode->predicate);
+            auto predicateExpr = desugar(ifNode->predicate);
             auto thenExpr = desugarStatements(ifNode->statements);
-            auto elsePreExpr = translate(ifNode->subsequent);
-
-            enforceHasExpr(predicatePreExpr, elsePreExpr);
-            auto predicateExpr = predicatePreExpr->takeDesugaredExpr();
-            auto elseExpr = takeDesugaredExprOrEmptyTree(elsePreExpr);
+            auto elseExpr = desugarNullable(ifNode->subsequent);
 
             auto expr = MK::If(location, move(predicateExpr), move(thenExpr), move(elseExpr));
             return expr_only(move(expr));
@@ -3352,16 +3361,10 @@ unique_ptr<parser::Node> Translator::translate(pm_node_t *node, bool preserveCon
         case PM_UNLESS_NODE: { // An `unless` branch, either in a statement or modifier form.
             auto unlessNode = down_cast<pm_unless_node>(node);
 
-            auto predicatePreExpr = translate(unlessNode->predicate);
+            auto predicateExpr = desugar(unlessNode->predicate);
             // For `unless`, then/else are swapped: `statements` is the else branch, `else_clause` is the then branch
             auto elseExpr = desugarStatements(unlessNode->statements);
-            ExpressionPtr thenExpr = MK::EmptyTree();
-            if (unlessNode->else_clause) {
-                thenExpr = desugarStatements(unlessNode->else_clause->statements);
-            }
-
-            enforceHasExpr(predicatePreExpr);
-            auto predicateExpr = predicatePreExpr->takeDesugaredExpr();
+            ExpressionPtr thenExpr = desugarNullable(up_cast(unlessNode->else_clause));
 
             auto expr = MK::If(location, move(predicateExpr), move(thenExpr), move(elseExpr));
             return expr_only(move(expr));

parser/prism/Translator.h

@@ -56,6 +56,7 @@ class Translator final {
           desugarUniqueCounter(this->desugarUniqueCounterStorage) {}
 
     ast::ExpressionPtr desugar(pm_node_t *node, bool preserveConcreteSyntax = false);
+    ast::ExpressionPtr desugarNullable(pm_node_t *node, bool preserveConcreteSyntax = false);
 
     // Translates the given AST from Prism's node types into the equivalent AST in Sorbet's legacy parser node types.
     std::unique_ptr<parser::Node> translate(pm_node_t *node, bool preserveConcreteSyntax = false);