Align with whitequark on locations of PM_CASE_NODE and PM_IT_PARAMETERS_NODE

Author: jesse-shopify

parser/prism/Translator.cc

@@ -2252,21 +2252,21 @@ ast::ExpressionPtr Translator::desugar(pm_node_t *node) {
             }
 
             auto elseClause = desugarNullable(up_cast(caseNode->else_clause));
-            // Capture the start of the line containing the `else` keyword.
+            // Capture the start of the line containing the `else` keyword (or `end` if no else clause).
             // Whitequark extends empty when bodies to the start of the next line (column 1), not to the
-            // `else` keyword itself. We find the start of the line by scanning backwards for a newline.
-            core::LocOffsets elseClauseLoc = core::LocOffsets::none();
+            // `else`/`end` keyword itself. We find the start of the line by scanning backwards for a newline.
+            core::LocOffsets clauseLoc;
             if (caseNode->else_clause != nullptr) {
-                auto elseLoc = translateLoc(caseNode->else_clause->base.location);
-                auto source = ctx.file.data(ctx).source();
-                uint32_t lineStart = elseLoc.beginPos();
-                // Scan backwards to find the start of the line
-                while (lineStart > 0 && source[lineStart - 1] != '\n') {
-                    lineStart--;
-                }
-                elseClauseLoc = core::LocOffsets{lineStart, elseLoc.endPos()};
+                clauseLoc = translateLoc(caseNode->else_clause->base.location);
+            } else {
+                // No else clause - use the `end` keyword location as the fallback
+                clauseLoc = translateLoc(caseNode->end_keyword_loc);
             }
 
+            auto detail = core::Loc::pos2Detail(ctx.file.data(ctx), clauseLoc.beginPos());
+            auto lineStart = core::Loc::detail2Pos(ctx.file.data(ctx), {detail.line, 1}).value();
+            core::LocOffsets nextClauseStartLoc = core::LocOffsets{lineStart, clauseLoc.endPos()};
+
             if (preserveConcreteSyntax) {
                 auto locZeroLen = location.copyWithZeroLength();
 
@@ -2303,7 +2303,9 @@ ast::ExpressionPtr Translator::desugar(pm_node_t *node) {
 
             core::NameRef tempName;
             core::LocOffsets predicateLoc;
-            bool hasPredicate = (predicate != nullptr);
+            // Check if the prism node has a predicate, not the desugared result,
+            // because desugarNullable returns EmptyTree (not nullptr) for null nodes.
+            bool hasPredicate = (caseNode->predicate != nullptr);
 
             if (hasPredicate) {
                 predicateLoc = predicate.loc();
@@ -2315,9 +2317,9 @@ ast::ExpressionPtr Translator::desugar(pm_node_t *node) {
             // The if/else ladder for the entire case statement, starting with the else clause as the final `else` when
             // building backwards
             ExpressionPtr resultExpr = move(elseClause);
-            // Track the location of the next clause (else or when) for extending empty when bodies.
-            // Initially this is the else clause location; after each iteration it becomes the If location.
-            core::LocOffsets nextClauseLoc = elseClauseLoc;
+            // Track the location of the next clause (else, end, or when) for extending empty when bodies.
+            // Initially this is the else/end clause location; after each iteration it becomes the If location.
+            core::LocOffsets nextClauseLoc = nextClauseStartLoc;
 
             // Iterate over Prism when nodes in reverse to build the if/else ladder backwards
             for (auto it = prismWhenNodes.rbegin(); it != prismWhenNodes.rend(); ++it) {
@@ -2363,16 +2365,22 @@ ast::ExpressionPtr Translator::desugar(pm_node_t *node) {
                 }
 
                 auto then = desugarStatements(prismWhen->statements);
-                // Whitequark extends the when clause location to include the start of the next clause,
+                // Whitequark extends the when clause location to include the start of the next line,
                 // but ONLY when the when body is empty. Use the start of nextClauseLoc as the end.
                 auto ifLoc = whenLoc;
                 bool bodyIsEmpty = (then == nullptr || ast::isa_tree<ast::EmptyTree>(then));
                 if (bodyIsEmpty && nextClauseLoc.exists()) {
                     ifLoc = core::LocOffsets{whenLoc.beginPos(), nextClauseLoc.beginPos()};
                 }
                 resultExpr = MK::If(ifLoc, move(patternsResult), move(then), move(resultExpr));
-                // Update nextClauseLoc to be this If's location for the next iteration
-                nextClauseLoc = ifLoc;
+                // Update nextClauseLoc to be the start of this when clause's LINE for the next iteration.
+                // This ensures empty when bodies extend to column 1, not to the indented clause start.
+                auto source = ctx.file.data(ctx).source();
+                uint32_t lineStart = whenLoc.beginPos();
+                while (lineStart > 0 && source[lineStart - 1] != '\n') {
+                    lineStart--;
+                }
+                nextClauseLoc = core::LocOffsets{lineStart, whenLoc.endPos()};
             }
 
             if (hasPredicate) {
@@ -4115,6 +4123,9 @@ core::LocOffsets Translator::findItParamUsageLoc(pm_statements_node *statements)
     core::LocOffsets result;
 
     walkPrismAST(up_cast(statements), [this, &result](const pm_node_t *node) -> bool {
+        if (result.exists()) {
+            return false;
+        }
         if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
             result = this->translateLoc(node->location);
             // Found the first usage, stop walking