prettier 2.0.0 → 2.1.0

data/dist/ruby/nodes/commands.js

@@ -10,11 +10,19 @@ const { align, group, ifBreak, indent, join, line, softline } = prettier_1.defau
 function throwBadDoc(doc) {
     throw new Error(`Unknown doc ${doc}`);
 }
+function reduceDocLength(sum, doc) {
+    // If we've hit a line, then we're going to start the counting back at 0 since
+    // it will be starting from the beginning of a line.
+    if (typeof doc === "object" && !Array.isArray(doc) && doc.type === "line") {
+        return 0;
+    }
+    return sum + docBreakLength(doc);
+}
 // Loop through the already created doc nodes and determine the overall length
 // so that we can properly align the command arguments.
-function docLength(doc) {
+function docBreakLength(doc) {
     if (Array.isArray(doc)) {
-        return doc.reduce((sum, child) => sum + docLength(child), 0);
+        return doc.reduce(reduceDocLength, 0);
     }
     if (typeof doc === "string") {
         return doc.length;
@@ -22,16 +30,16 @@ function docLength(doc) {
     switch (doc.type) {
         case "concat":
         case "fill":
-            return doc.parts.reduce((sum, child) => sum + docLength(child), 0);
+            return doc.parts.reduce(reduceDocLength, 0);
         case "align":
         case "group":
         case "indent":
         case "line-suffix":
-            return docLength(doc.contents);
+            return docBreakLength(doc.contents);
         case "if-break":
-            return docLength(doc.flatContents);
+            return docBreakLength(doc.breakContents);
         case "line":
-            return doc.soft ? 0 : 1;
+            return 0;
         case "break-parent":
         case "cursor":
         case "indent-if-break":
@@ -44,10 +52,10 @@ function docLength(doc) {
     }
 }
 function hasDef(node) {
-    return (node.body[1].type === "args_add_block" &&
-        node.body[1].body[0].type === "args" &&
-        node.body[1].body[0].body[0] &&
-        ["def", "defs"].includes(node.body[1].body[0].body[0].type));
+    return (node.args.type === "args_add_block" &&
+        node.args.args.type === "args" &&
+        node.args.args.parts[0] &&
+        ["def", "defs"].includes(node.args.args.parts[0].type));
 }
 // Very special handling case for rspec matchers. In general with rspec matchers
 // you expect to see something like:
@@ -63,19 +71,25 @@ function hasDef(node) {
 // In this case the arguments are aligned to the left side as opposed to being
 // aligned with the `receive` call.
 function skipArgsAlign(node) {
-    return ["to", "not_to", "to_not"].includes(node.body[2].body);
+    return ["to", "not_to", "to_not"].includes(node.message.value);
 }
 // If there is a ternary argument to a command and it's going to get broken
 // into multiple lines, then we're going to have to use parentheses around the
 // command in order to make sure operator precedence doesn't get messed up.
 function hasTernaryArg(node) {
-    return node.body[0].body.some((child) => child.type === "ifop");
+    var _a;
+    switch (node.type) {
+        case "args":
+            return node.parts.some((child) => child.type === "ifop");
+        case "args_add_block":
+            return hasTernaryArg(node.args) || ((_a = node.block) === null || _a === void 0 ? void 0 : _a.type) === "ifop";
+    }
 }
 const printCommand = (path, opts, print) => {
     const node = path.getValue();
-    const command = path.call(print, "body", 0);
-    const joinedArgs = join([",", line], path.call(print, "body", 1));
-    const hasTernary = hasTernaryArg(node.body[1]);
+    const command = path.call(print, "message");
+    const joinedArgs = join([",", line], path.call(print, "args"));
+    const hasTernary = hasTernaryArg(node.args);
     let breakArgs;
     if (hasTernary) {
         breakArgs = indent([softline, joinedArgs]);
@@ -84,7 +98,7 @@ const printCommand = (path, opts, print) => {
         breakArgs = joinedArgs;
     }
     else {
-        breakArgs = align(docLength(command) + 1, joinedArgs);
+        breakArgs = align(docBreakLength(command) + 1, joinedArgs);
     }
     return group(ifBreak([
         command,
@@ -97,16 +111,16 @@ exports.printCommand = printCommand;
 const printCommandCall = (path, opts, print) => {
     const node = path.getValue();
     const parts = [
-        path.call(print, "body", 0),
+        path.call(print, "receiver"),
         (0, utils_1.makeCall)(path, opts, print),
-        path.call(print, "body", 2)
+        path.call(print, "message")
     ];
-    if (!node.body[3]) {
+    if (!node.args) {
         return parts;
     }
-    const argDocs = join([",", line], path.call(print, "body", 3));
+    const argDocs = join([",", line], path.call(print, "args"));
     let breakDoc;
-    if (hasTernaryArg(node.body[3])) {
+    if (hasTernaryArg(node.args)) {
         breakDoc = parts.concat("(", indent([softline, argDocs]), softline, ")");
         parts.push(" ");
     }
@@ -116,7 +130,7 @@ const printCommandCall = (path, opts, print) => {
     }
     else {
         parts.push(" ");
-        breakDoc = parts.concat(align(docLength(parts), argDocs));
+        breakDoc = parts.concat(align(docBreakLength(parts), argDocs));
     }
     const joinedDoc = parts.concat(argDocs);
     return group(ifBreak(breakDoc, joinedDoc));

data/dist/ruby/nodes/conditionals.js

@@ -16,9 +16,9 @@ function containsSingleConditional(stmts) {
 function printWithAddition(keyword, path, print, breaking) {
     return [
         `${keyword} `,
-        align(keyword.length + 1, path.call(print, "body", 0)),
-        indent([softline, path.call(print, "body", 1)]),
-        [softline, path.call(print, "body", 2)],
+        align(keyword.length + 1, path.call(print, "pred")),
+        indent([softline, path.call(print, "stmts")]),
+        [softline, path.call(print, "cons")],
         [softline, "end"],
         breaking ? breakParent : ""
     ];
@@ -54,26 +54,30 @@ function printTernaryClauses(keyword, truthyClause, falsyClause) {
 // Handles ternary nodes. If it does not fit on one line, then we break out into
 // an if/else statement. Otherwise we remain as a ternary.
 const printTernary = (path, _opts, print) => {
-    const [predicate, truthyClause, falsyClause] = path.map(print, "body");
-    const ternaryClauses = printTernaryClauses("if", truthyClause, falsyClause);
+    const predicateDoc = path.call(print, "pred");
+    const truthyDoc = path.call(print, "tthy");
+    const falsyDoc = path.call(print, "flsy");
     return group(ifBreak([
         "if ",
-        align(3, predicate),
-        indent([softline, truthyClause]),
+        align(3, predicateDoc),
+        indent([softline, truthyDoc]),
         [softline, "else"],
-        indent([softline, falsyClause]),
+        indent([softline, falsyDoc]),
         [softline, "end"]
-    ], [predicate, " ? ", ...ternaryClauses]));
+    ], [predicateDoc, " ? ", ...printTernaryClauses("if", truthyDoc, falsyDoc)]));
 };
 exports.printTernary = printTernary;
+function isModifier(node) {
+    return node.type === "if_mod" || node.type === "unless_mod";
+}
 // Prints an `if_mod` or `unless_mod` node. Because it was previously in the
 // modifier form, we're guaranteed to not have an additional node, so we can
 // just work with the predicate and the body.
-function printSingle(keyword, modifier = false) {
+function printSingle(keyword) {
     return function printSingleWithKeyword(path, { rubyModifier }, print) {
-        const [, statementsNode] = path.getValue().body;
-        const predicateDoc = path.call(print, "body", 0);
-        const statementsDoc = path.call(print, "body", 1);
+        const node = path.getValue();
+        const predicateDoc = path.call(print, "pred");
+        const statementsDoc = path.call(print, isModifier(node) ? "stmt" : "stmts");
         const multilineParts = [
             `${keyword} `,
             align(keyword.length + 1, predicateDoc),
@@ -84,22 +88,21 @@ function printSingle(keyword, modifier = false) {
         // If we do not allow modifier form conditionals or there are comments
         // inside of the body of the conditional, then we must print in the
         // multiline form.
-        if (!rubyModifier ||
-            (!modifier && statementsNode.body[0].comments)) {
+        if (!rubyModifier || (!isModifier(node) && node.stmts.body[0].comments)) {
             return [multilineParts, breakParent];
         }
         const inline = (0, utils_1.inlineEnsureParens)(path, [
-            path.call(print, "body", 1),
+            statementsDoc,
             ` ${keyword} `,
-            path.call(print, "body", 0)
+            predicateDoc
         ]);
-        // An expression with a conditional modifier (expression if true), the
+        // With an expression with a conditional modifier (expression if true), the
         // conditional body is parsed before the predicate expression, meaning that
         // if the parser encountered a variable declaration, it would initialize
         // that variable first before evaluating the predicate expression. That
         // parse order means the difference between a NameError or not. #591
         // https://docs.ruby-lang.org/en/2.0.0/syntax/control_expressions_rdoc.html#label-Modifier+if+and+unless
-        if (modifier && (0, utils_1.containsAssignment)(statementsNode)) {
+        if (isModifier(node) && (0, utils_1.containsAssignment)(node.stmt)) {
             return inline;
         }
         return group(ifBreak(multilineParts, inline));
@@ -144,7 +147,7 @@ function canTernaryStmts(stmts) {
     const stmt = stmts.body[0];
     // If the user is using one of the lower precedence "and" or "or" operators,
     // then we can't use a ternary expression as it would break the flow control.
-    if (stmt.type === "binary" && ["and", "or"].includes(stmt.body[1])) {
+    if (stmt.type === "binary" && ["and", "or"].includes(stmt.op)) {
         return false;
     }
     // Check against the blocklist of statement types that are not allowed to be
@@ -157,55 +160,56 @@ function canTernaryStmts(stmts) {
 // additional node must have only one statement, and that statement list must
 // pass the `canTernaryStmts` check.
 function canTernary(path) {
-    const [predicate, stmts, addition] = path.getValue().body;
-    return (!["assign", "opassign", "command_call", "command"].includes(predicate.type) &&
-        addition &&
-        addition.type === "else" &&
-        [stmts, addition.body[0]].every(canTernaryStmts));
+    const node = path.getValue();
+    return (!["assign", "opassign", "command_call", "command"].includes(node.pred.type) &&
+        node.cons &&
+        node.cons.type === "else" &&
+        canTernaryStmts(node.stmts) &&
+        canTernaryStmts(node.cons.stmts));
 }
 // A normalized print function for both `if` and `unless` nodes.
 function printConditional(keyword) {
-    return (path, opts, print) => {
+    return function printConditionalWithKeyword(path, opts, print) {
         if (canTernary(path)) {
             let ternaryParts = [
-                path.call(print, "body", 0),
+                path.call(print, "pred"),
                 " ? ",
-                ...printTernaryClauses(keyword, path.call(print, "body", 1), path.call(print, "body", 2, "body", 0))
+                ...printTernaryClauses(keyword, path.call(print, "stmts"), path.call(print, "cons", "stmts"))
             ];
             if (["binary", "call"].includes(path.getParentNode().type)) {
                 ternaryParts = ["(", ...ternaryParts, ")"];
             }
             return group(ifBreak(printWithAddition(keyword, path, print, false), ternaryParts));
         }
-        const [predicate, statements, addition] = path.getValue().body;
+        const node = path.getValue();
         // If there's an additional clause that wasn't matched earlier, we know we
         // can't go for the inline option.
-        if (addition) {
+        if (node.cons) {
             return group(printWithAddition(keyword, path, print, true));
         }
-        // If the body of the conditional is empty, then we explicitly have to use the
-        // block form.
-        if ((0, utils_1.isEmptyStmts)(statements)) {
+        // If the body of the conditional is empty, then we explicitly have to use
+        // the block form.
+        if ((0, utils_1.isEmptyStmts)(node.stmts)) {
             return [
                 `${keyword} `,
-                align(keyword.length + 1, path.call(print, "body", 0)),
+                align(keyword.length + 1, path.call(print, "pred")),
                 hardline,
                 "end"
             ];
         }
         // Two situations in which we need to use the block form:
         //
-        // 1. If the predicate of the conditional contains an assignment, then we can't
-        // know for sure that it doesn't impact the body of the conditional.
+        // 1. If the predicate of the conditional contains an assignment, then we
+        // can't know for sure that it doesn't impact the body of the conditional.
         //
-        // 2. If the conditional contains just another conditional, then collapsing it
-        // would result in double modifiers on the same line.
-        if ((0, utils_1.containsAssignment)(predicate) ||
-            containsSingleConditional(statements)) {
+        // 2. If the conditional contains just another conditional, then collapsing
+        // it would result in double modifiers on the same line.
+        if ((0, utils_1.containsAssignment)(node.pred) ||
+            containsSingleConditional(node.stmts)) {
             return [
                 `${keyword} `,
-                align(keyword.length + 1, path.call(print, "body", 0)),
-                indent([hardline, path.call(print, "body", 1)]),
+                align(keyword.length + 1, path.call(print, "pred")),
+                indent([hardline, path.call(print, "stmts")]),
                 hardline,
                 "end"
             ];
@@ -214,29 +218,29 @@ function printConditional(keyword) {
     };
 }
 const printElse = (path, opts, print) => {
-    const stmts = path.getValue().body[0];
+    const node = path.getValue();
     return [
-        stmts.body.length === 1 && stmts.body[0].type === "command"
+        node.stmts.body.length === 1 && node.stmts.body[0].type === "command"
             ? breakParent
             : "",
         "else",
-        indent([softline, path.call(print, "body", 0)])
+        indent([softline, path.call(print, "stmts")])
     ];
 };
 exports.printElse = printElse;
 const printElsif = (path, opts, print) => {
-    const [, , addition] = path.getValue().body;
+    const node = path.getValue();
     const parts = [
-        group(["elsif ", align("elsif".length - 1, path.call(print, "body", 0))]),
-        indent([hardline, path.call(print, "body", 1)])
+        group(["elsif ", align("elsif".length - 1, path.call(print, "pred"))]),
+        indent([hardline, path.call(print, "stmts")])
     ];
-    if (addition) {
-        parts.push(group([hardline, path.call(print, "body", 2)]));
+    if (node.cons) {
+        parts.push(group([hardline, path.call(print, "cons")]));
     }
     return group(parts);
 };
 exports.printElsif = printElsif;
 exports.printIf = printConditional("if");
-exports.printIfModifier = printSingle("if", true);
+exports.printIfModifier = printSingle("if");
 exports.printUnless = printConditional("unless");
-exports.printUnlessModifier = printSingle("unless", true);
+exports.printUnlessModifier = printSingle("unless");

data/dist/ruby/nodes/constants.js

@@ -6,19 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.printTopConst = exports.printField = exports.printDefined = exports.printConstRef = exports.printConstPath = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
-const { group, indent, join, softline } = prettier_1.default;
-const printConstPath = (path, opts, print) => {
-    return join("::", path.map(print, "body"));
-};
+const { group, indent, softline } = prettier_1.default;
+const printConstPath = (path, opts, print) => [path.call(print, "parent"), "::", path.call(print, "constant")];
 exports.printConstPath = printConstPath;
-const printConstRef = (path, opts, print) => {
-    return path.call(print, "body", 0);
-};
+const printConstRef = (path, opts, print) => path.call(print, "constant");
 exports.printConstRef = printConstRef;
 const printDefined = (path, opts, print) => {
     return group([
         "defined?(",
-        indent([softline, path.call(print, "body", 0)]),
+        indent([softline, path.call(print, "value")]),
         softline,
         ")"
     ]);
@@ -26,13 +22,14 @@ const printDefined = (path, opts, print) => {
 exports.printDefined = printDefined;
 const printField = (path, opts, print) => {
     return group([
-        path.call(print, "body", 0),
+        path.call(print, "parent"),
         (0, utils_1.makeCall)(path, opts, print),
-        path.call(print, "body", 2)
+        path.call(print, "name")
     ]);
 };
 exports.printField = printField;
-const printTopConst = (path, opts, print) => {
-    return ["::", path.call(print, "body", 0)];
-};
+const printTopConst = (path, opts, print) => [
+    "::",
+    path.call(print, "constant")
+];
 exports.printTopConst = printTopConst;

data/dist/ruby/nodes/flow.js

@@ -5,15 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printYield0 = exports.printYield = exports.printNext = exports.printBreak = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
 const { join } = prettier_1.default;
-function nodeDive(node, steps) {
-    let current = node;
-    steps.forEach((step) => {
-        current = current[step];
-    });
-    return current;
-}
+// If there are parentheses around these nodes, then we can't skip printing them
+// without changing the semantic meaning of the statement.
 const unskippableParens = [
     "if_mod",
     "rescue_mod",
@@ -21,46 +15,45 @@ const unskippableParens = [
     "until_mod",
     "while_mod"
 ];
-function maybeHandleParens(path, print, keyword, steps) {
-    const node = nodeDive(path.getValue(), steps);
-    if (node.type !== "paren") {
-        return null;
-    }
-    const stmts = node.body[0].body;
-    if (stmts.length === 1 && !unskippableParens.includes(stmts[0].type)) {
-        return [`${keyword} `, path.call(print, ...steps, "body", 0)];
-    }
-    return [keyword, path.call(print, ...steps)];
+function printFlowControl(keyword) {
+    return function printFlowControlWithKeyword(path, opts, print) {
+        const node = path.getValue();
+        // If we don't have any arguments to the keyword, then it's always going to
+        // come in as an args node, in which case we can just print the keyword.
+        if (node.args.type === "args") {
+            return keyword;
+        }
+        // Special handling if we've got parentheses on this call to the keyword. If
+        // we do and we can skip them, then we will. If we don't, then we'll print
+        // them right after the keyword with no space.
+        const paren = node.args.args.type === "args" && node.args.args.parts[0];
+        if (paren && paren.type === "paren") {
+            const stmts = paren.cnts.body;
+            // Here we're checking if we can skip past the parentheses entirely.
+            if (stmts.length === 1 && !unskippableParens.includes(stmts[0].type)) {
+                return [
+                    `${keyword} `,
+                    path.call(print, "args", "args", "parts", 0, "cnts")
+                ];
+            }
+            // Here we know we can't, so just printing out the parentheses as normal.
+            return [keyword, path.call(print, "args", "args", "parts", 0)];
+        }
+        // If we didn't hit the super special handling, then we're just going to
+        // print out the arguments to the keyword like normal.
+        return [`${keyword} `, join(", ", path.call(print, "args"))];
+    };
 }
-const printBreak = (path, opts, print) => {
-    const content = path.getValue().body[0];
-    if (content.body.length === 0) {
-        return "break";
-    }
-    const steps = ["body", 0, "body", 0, "body", 0];
-    return (maybeHandleParens(path, print, "break", steps) || [
-        "break ",
-        join(", ", path.call(print, "body", 0))
-    ]);
-};
-exports.printBreak = printBreak;
-const printNext = (path, opts, print) => {
-    const args = path.getValue().body[0].body[0];
-    if (!args) {
-        return "next";
-    }
-    const steps = ["body", 0, "body", 0, "body", 0];
-    return (maybeHandleParens(path, print, "next", steps) || [
-        "next ",
-        join(", ", path.call(print, "body", 0))
-    ]);
-};
-exports.printNext = printNext;
+exports.printBreak = printFlowControl("break");
+exports.printNext = printFlowControl("next");
 const printYield = (path, opts, print) => {
-    if (path.getValue().body[0].type === "paren") {
-        return ["yield", path.call(print, "body", 0)];
+    const node = path.getValue();
+    const argsDoc = path.call(print, "args");
+    if (node.args.type === "paren") {
+        return ["yield", argsDoc];
     }
-    return ["yield ", join(", ", path.call(print, "body", 0))];
+    return ["yield ", join(", ", argsDoc)];
 };
 exports.printYield = printYield;
-exports.printYield0 = (0, utils_1.literal)("yield");
+const printYield0 = (path) => path.getValue().value;
+exports.printYield0 = printYield0;

data/dist/ruby/nodes/hashes.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printHash = exports.printHashContents = exports.printAssocSplat = exports.printAssocNew = void 0;
+exports.printHash = exports.printHashContents = exports.printAssocSplat = exports.printAssoc = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { group, ifBreak, indent, join, line } = prettier_1.default;
@@ -18,19 +18,19 @@ const { group, ifBreak, indent, join, line } = prettier_1.default;
 // This function represents that check, as it determines if it can convert the
 // symbol node into a hash label.
 function isValidHashLabel(symbolLiteral) {
-    const label = symbolLiteral.body[0].body;
+    const label = symbolLiteral.value.value;
     return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
 }
 function canUseHashLabels(contentsNode) {
-    return contentsNode.body.every((assocNode) => {
+    return contentsNode.assocs.every((assocNode) => {
         if (assocNode.type === "assoc_splat") {
             return true;
         }
-        switch (assocNode.body[0].type) {
-            case "@label":
+        switch (assocNode.key.type) {
+            case "label":
                 return true;
             case "symbol_literal":
-                return isValidHashLabel(assocNode.body[0]);
+                return isValidHashLabel(assocNode.key);
             case "dyna_symbol":
                 return true;
             default:
@@ -41,12 +41,10 @@ function canUseHashLabels(contentsNode) {
 const printHashKeyLabel = (path, print) => {
     const node = path.getValue();
     switch (node.type) {
-        case "@label":
+        case "label":
             return print(path);
-        case "symbol_literal": {
-            const nodePath = path;
-            return [nodePath.call(print, "body", 0), ":"];
-        }
+        case "symbol_literal":
+            return [path.call(print, "value"), ":"];
         case "dyna_symbol":
             return [print(path), ":"];
         default:
@@ -58,7 +56,7 @@ const printHashKeyLabel = (path, print) => {
 const printHashKeyRocket = (path, print) => {
     const node = path.getValue();
     let doc = print(path);
-    if (node.type === "@label") {
+    if (node.type === "label") {
         const sDoc = doc; // since we know this is a label
         doc = [":", sDoc.slice(0, sDoc.length - 1)];
     }
@@ -67,18 +65,18 @@ const printHashKeyRocket = (path, print) => {
     }
     return [doc, " =>"];
 };
-const printAssocNew = (path, opts, print) => {
-    const [keyNode, valueNode] = path.getValue().body;
+const printAssoc = (path, opts, print) => {
+    const node = path.getValue();
     const { keyPrinter } = path.getParentNode();
-    const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "body", 0)];
-    const valueDoc = path.call(print, "body", 1);
+    const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "key")];
+    const valueDoc = path.call(print, "value");
     // If we're printing a child hash then we want it to break along with its
     // parent hash, so we don't group the parts.
-    if (valueNode.type === "hash") {
+    if (node.value.type === "hash") {
         parts.push(" ", valueDoc);
         return parts;
     }
-    if (!(0, utils_1.skipAssignIndent)(valueNode) || keyNode.comments) {
+    if (!(0, utils_1.skipAssignIndent)(node.value) || node.key.comments) {
         parts.push(indent([line, valueDoc]));
     }
     else {
@@ -86,10 +84,8 @@ const printAssocNew = (path, opts, print) => {
     }
     return group(parts);
 };
-exports.printAssocNew = printAssocNew;
-const printAssocSplat = (path, opts, print) => {
-    return ["**", path.call(print, "body", 0)];
-};
+exports.printAssoc = printAssoc;
+const printAssocSplat = (path, opts, print) => ["**", path.call(print, "value")];
 exports.printAssocSplat = printAssocSplat;
 const printHashContents = (path, opts, print) => {
     const node = path.getValue();
@@ -99,22 +95,22 @@ const printHashContents = (path, opts, print) => {
         opts.rubyHashLabel && canUseHashLabels(path.getValue())
             ? printHashKeyLabel
             : printHashKeyRocket;
-    return join([",", line], path.map(print, "body"));
+    return join([",", line], path.map(print, "assocs"));
 };
 exports.printHashContents = printHashContents;
 const printHash = (path, opts, print) => {
-    const hashNode = path.getValue();
+    const node = path.getValue();
     // Hashes normally have a single assoclist_from_args child node. If it's
     // missing, then it means we're dealing with an empty hash, so we can just
     // exit here and print.
-    if (hashNode.body[0] === null) {
+    if (node.cnts === null) {
         return (0, utils_1.printEmptyCollection)(path, opts, "{", "}");
     }
-    const hashDoc = [
+    const doc = [
         "{",
         indent([
             line,
-            path.call(print, "body", 0),
+            path.call(print, "cnts"),
             (0, utils_1.getTrailingComma)(opts) ? ifBreak(",", "") : ""
         ]),
         line,
@@ -122,9 +118,9 @@ const printHash = (path, opts, print) => {
     ];
     // If we're inside another hash, then we don't want to group our contents
     // because we want this hash to break along with its parent hash.
-    if (path.getParentNode().type === "assoc_new") {
-        return hashDoc;
+    if (path.getParentNode().type === "assoc") {
+        return doc;
     }
-    return group(hashDoc);
+    return group(doc);
 };
 exports.printHash = printHash;

data/dist/ruby/nodes/heredocs.js

@@ -8,15 +8,15 @@ const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { group, lineSuffix, join } = prettier_1.default;
 const printHeredoc = (path, opts, print) => {
-    const { body, ending } = path.getValue();
-    const parts = body.map((part, index) => {
-        if (part.type !== "@tstring_content") {
-            // In this case, the part of the string is an embedded expression
-            return path.call(print, "body", index);
+    const node = path.getValue();
+    // Print out each part of the heredoc to its own doc node.
+    const parts = path.map((partPath) => {
+        const part = partPath.getValue();
+        if (part.type !== "tstring_content") {
+            return print(partPath);
         }
-        // In this case, the part of the string is just regular string content
-        return join(utils_1.literallineWithoutBreakParent, part.body.split(/\r?\n/));
-    });
+        return join(utils_1.literallineWithoutBreakParent, part.value.split(/\r?\n/));
+    }, "parts");
     // We use a literalline break because matching indentation is required
     // for the heredoc contents and ending. If the line suffix contains a
     // break-parent, all ancestral groups are broken, and heredocs automatically
@@ -24,7 +24,7 @@ const printHeredoc = (path, opts, print) => {
     // possible, so we use a literalline without the break-parent.
     return group([
         path.call(print, "beging"),
-        lineSuffix(group([utils_1.literallineWithoutBreakParent, ...parts, ending]))
+        lineSuffix(group([utils_1.literallineWithoutBreakParent, ...parts, node.ending]))
     ]);
 };
 exports.printHeredoc = printHeredoc;