prettier 2.0.0.pre.rc3 → 2.1.0

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;

data/dist/ruby/nodes/hooks.js

@@ -25,8 +25,8 @@ function printHook(name) {
         return group([
             name,
             " ",
-            path.call(print, "body", 0),
-            indent([line, path.call(print, "body", 1)]),
+            path.call(print, "lbrace"),
+            indent([line, path.call(print, "stmts")]),
             [line, "}"]
         ]);
     };

data/dist/ruby/nodes/ints.js

@@ -6,22 +6,22 @@ exports.printInt = void 0;
 //
 // Binary (2)       - 0b0110
 // Octal (8)        - 0o34 or 034
-// Decimal (10)     - a normal number like 159
+// Decimal (10)     - 159 or 0d159
 // Hexidecimal (16) - 0xac5
 //
 // If it's a decimal number, it can be optional separated by any number of
 // arbitrarily places underscores. This can be useful for dollars and cents
 // (34_99), dates (2020_11_30), and normal 3 digit separation (1_222_333).
 const printInt = (path) => {
-    const { body } = path.getValue();
+    const { value } = path.getValue();
     // If the number is a base 10 number, is sufficiently large, and is not
     // already formatted with underscores, then add them in in between the
     // numbers every three characters starting from the right.
-    if (!body.startsWith("0") && body.length >= 5 && !body.includes("_")) {
+    if (!value.startsWith("0") && value.length >= 5 && !value.includes("_")) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const segments = `  ${body}`.slice((body.length + 2) % 3).match(/.{3}/g);
+        const segments = `  ${value}`.slice((value.length + 2) % 3).match(/.{3}/g);
         return segments.join("_").trim();
     }
-    return body;
+    return value;
 };
 exports.printInt = printInt;

data/dist/ruby/nodes/lambdas.js

@@ -12,19 +12,19 @@ const { group, ifBreak, indent, line } = prettier_1.default;
 // though it's possible to omit the parens if you only have one argument, we're
 // going to keep them in no matter what for consistency.
 function printLambdaParams(path, print) {
-    let node = path.getValue().body[0];
+    let node = path.getValue().params;
     // In this case we had something like -> (foo) { bar } which would mean that
     // we're looking at a paren node, so we'll descend one level deeper to get at
     // the actual params node.
     if (node.type !== "params") {
-        node = node.body[0];
+        node = node.cnts;
     }
     // If we don't have any params at all, then we're just going to bail out and
     // print nothing. This is to avoid printing an empty set of parentheses.
-    if (node.body.every((type) => !type)) {
+    if ((0, utils_1.isEmptyParams)(node)) {
         return "";
     }
-    return path.call(print, "body", 0);
+    return path.call(print, "params");
 }
 // Lambda nodes represent stabby lambda literals, which can come in a couple of
 // flavors. They can use either braces or do...end for their block, and their
@@ -56,14 +56,15 @@ function printLambdaParams(path, print) {
 const printLambda = (path, opts, print) => {
     const params = printLambdaParams(path, print);
     const inCommand = (0, utils_1.hasAncestor)(path, ["command", "command_call"]);
+    const stmtsDoc = path.call(print, "stmts");
     return group(ifBreak([
         "->",
         params,
         " ",
         inCommand ? "{" : "do",
-        indent([line, path.call(print, "body", 1)]),
+        indent([line, stmtsDoc]),
         line,
         inCommand ? "}" : "end"
-    ], ["->", params, " { ", path.call(print, "body", 1), " }"]));
+    ], ["->", params, " { ", stmtsDoc, " }"]));
 };
 exports.printLambda = printLambda;

data/dist/ruby/nodes/loops.js

@@ -3,26 +3,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printUntilModifer = exports.printUntil = exports.printWhileModifier = exports.printWhile = exports.printFor = void 0;
+exports.printUntil = exports.printWhile = exports.printFor = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { align, breakParent, group, hardline, ifBreak, indent, join, softline } = prettier_1.default;
-function printLoop(keyword, modifier) {
+function isModifier(node) {
+    return node.type === "while_mod" || node.type === "until_mod";
+}
+function printLoop(keyword) {
     return function printLoopWithOptions(path, { rubyModifier }, print) {
-        const [, stmts] = path.getValue().body;
+        const node = path.getValue();
+        const predicateDoc = path.call(print, "pred");
         // If the only statement inside this while loop is a void statement, then we
         // can shorten to just displaying the predicate and then a semicolon.
-        if ((0, utils_1.isEmptyStmts)(stmts)) {
-            return group([
-                group([keyword, " ", path.call(print, "body", 0)]),
-                hardline,
-                "end"
-            ]);
+        if (!isModifier(node) && (0, utils_1.isEmptyStmts)(node.stmts)) {
+            return group([group([keyword, " ", predicateDoc]), hardline, "end"]);
         }
+        const statementDoc = path.call(print, isModifier(node) ? "stmt" : "stmts");
         const inlineLoop = (0, utils_1.inlineEnsureParens)(path, [
-            path.call(print, "body", 1),
+            statementDoc,
             ` ${keyword} `,
-            path.call(print, "body", 0)
+            predicateDoc
         ]);
         // If we're in the modifier form and we're modifying a `begin`, then this is
         // a special case where we need to explicitly use the modifier form because
@@ -34,12 +35,12 @@ function printLoop(keyword, modifier) {
         //
         // The above is effectively a `do...while` loop (which we don't have in
         // ruby).
-        if (modifier && path.getValue().body[1].type === "begin") {
+        if (isModifier(node) && node.stmt.type === "begin") {
             return inlineLoop;
         }
         const blockLoop = [
-            [`${keyword} `, align(keyword.length + 1, path.call(print, "body", 0))],
-            indent([softline, path.call(print, "body", 1)]),
+            [`${keyword} `, align(keyword.length + 1, predicateDoc)],
+            indent([softline, statementDoc]),
             softline,
             "end"
         ];
@@ -47,27 +48,28 @@ function printLoop(keyword, modifier) {
         // contains an assignment (in which case we can't know for certain that that
         // assignment doesn't impact the statements inside the loop) then we can't
         // use the modifier form and we must use the block form.
-        if (!rubyModifier || (0, utils_1.containsAssignment)(path.getValue().body[0])) {
+        if (!rubyModifier || (0, utils_1.containsAssignment)(node.pred)) {
             return [breakParent, blockLoop];
         }
         return group(ifBreak(blockLoop, inlineLoop));
     };
 }
 const printFor = (path, opts, print) => {
-    const [varDoc, rangeDoc, stmtsDoc] = path.map(print, "body");
-    const varsDoc = path.getValue().body[0].type === "mlhs" ? join(", ", varDoc) : varDoc;
+    const node = path.getValue();
+    let indexDoc = path.call(print, "index");
+    if (node.index.type === "mlhs") {
+        indexDoc = join(", ", indexDoc);
+    }
     return group([
         "for ",
-        varsDoc,
+        indexDoc,
         " in ",
-        rangeDoc,
-        indent([hardline, stmtsDoc]),
+        path.call(print, "collection"),
+        indent([hardline, path.call(print, "stmts")]),
         hardline,
         "end"
     ]);
 };
 exports.printFor = printFor;
-exports.printWhile = printLoop("while", false);
-exports.printWhileModifier = printLoop("while", true);
-exports.printUntil = printLoop("until", false);
-exports.printUntilModifer = printLoop("until", true);
+exports.printWhile = printLoop("while");
+exports.printUntil = printLoop("until");

data/dist/ruby/nodes/massign.js

@@ -3,71 +3,58 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printMRHSNewFromArgs = exports.printMRHSAddStar = exports.printMRHS = exports.printMLHSParen = exports.printMLHSAddStar = exports.printMLHSAddPost = exports.printMLHS = exports.printMAssign = void 0;
+exports.printMRHSNewFromArgs = exports.printMRHSAddStar = exports.printMRHS = exports.printMLHSParen = exports.printMLHS = exports.printMAssign = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const { group, indent, join, line, softline } = prettier_1.default;
 const printMAssign = (path, opts, print) => {
-    let right = path.call(print, "body", 1);
-    if (["mrhs_add_star", "mrhs_new_from_args"].includes(path.getValue().body[1].type)) {
-        right = group(join([",", line], right));
+    const node = path.getValue();
+    let valueDoc = path.call(print, "value");
+    if (["mrhs", "mrhs_add_star", "mrhs_new_from_args"].includes(node.value.type)) {
+        valueDoc = group(join([",", line], valueDoc));
     }
-    const parts = [join([",", line], path.call(print, "body", 0))];
-    if (path.getValue().body[0].comma) {
-        parts.push(",");
+    const targetDoc = [
+        join([",", line], path.call(print, "target"))
+    ];
+    if (node.target.type === "mlhs" && node.target.comma) {
+        targetDoc.push(",");
     }
-    return group([group(parts), " =", indent([line, right])]);
+    return group([group(targetDoc), " =", indent([line, valueDoc])]);
 };
 exports.printMAssign = printMAssign;
 const printMLHS = (path, opts, print) => {
-    return path.map(print, "body");
+    return path.map(print, "parts");
 };
 exports.printMLHS = printMLHS;
-const printMLHSAddPost = (path, opts, print) => {
-    return [
-        ...path.call(print, "body", 0),
-        ...path.call(print, "body", 1)
-    ];
-};
-exports.printMLHSAddPost = printMLHSAddPost;
-const printMLHSAddStar = (path, opts, print) => {
-    const parts = ["*"];
-    if (path.getValue().body[1]) {
-        parts.push(path.call(print, "body", 1));
-    }
-    return [...path.call(print, "body", 0), parts];
-};
-exports.printMLHSAddStar = printMLHSAddStar;
 const printMLHSParen = (path, opts, print) => {
     if (["massign", "mlhs_paren"].includes(path.getParentNode().type)) {
         // If we're nested in brackets as part of the left hand side of an
         // assignment, i.e., (a, b, c) = 1, 2, 3
         // ignore the current node and just go straight to the content
-        return path.call(print, "body", 0);
+        return path.call(print, "cnts");
     }
+    const node = path.getValue();
     const parts = [
         softline,
-        join([",", line], path.call(print, "body", 0))
+        join([",", line], path.call(print, "cnts"))
     ];
-    if (path.getValue().body[0].comma) {
+    if (node.cnts.comma) {
         parts.push(",");
     }
     return group(["(", indent(parts), [softline, ")"]]);
 };
 exports.printMLHSParen = printMLHSParen;
 const printMRHS = (path, opts, print) => {
-    return path.map(print, "body");
+    return path.map(print, "parts");
 };
 exports.printMRHS = printMRHS;
 const printMRHSAddStar = (path, opts, print) => {
-    const [leftDoc, rightDoc] = path.map(print, "body");
-    return [...leftDoc, ["*", rightDoc]];
+    return [
+        ...path.call(print, "mrhs"),
+        ["*", path.call(print, "star")]
+    ];
 };
 exports.printMRHSAddStar = printMRHSAddStar;
 const printMRHSNewFromArgs = (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
-    if (path.getValue().body[1]) {
-        parts.push(path.call(print, "body", 1));
-    }
-    return parts;
+    return path.call(print, "args");
 };
 exports.printMRHSNewFromArgs = printMRHSNewFromArgs;

data/dist/ruby/nodes/methods.js

@@ -3,68 +3,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printAccessControl = exports.printSingleLineMethod = exports.printDef = void 0;
+exports.printAccessControl = exports.printDefEndless = exports.printDef = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { group, hardline, indent, line } = prettier_1.default;
 const printDef = (path, opts, print) => {
     const node = path.getValue();
     const declaration = ["def "];
-    let paramsNode;
-    let bodystmtNode;
-    let nameDoc;
-    let paramsDoc;
-    let bodystmtDoc;
-    if (node.type === "def") {
-        paramsNode = node.body[1];
-        bodystmtNode = node.body[2];
-        nameDoc = path.call(print, "body", 0);
-        paramsDoc = path.call(print, "body", 1);
-        bodystmtDoc = path.call(print, "body", 2);
+    // In this case, we're printing a method that's defined as a singleton, so
+    // we need to include the target and the operator before the name.
+    if (node.type === "defs") {
+        declaration.push(path.call(print, "target"), path.call(print, "op"));
     }
-    else {
-        // In this case, we're printing a method that's defined as a singleton, so
-        // we need to include the target and the operator
-        declaration.push(path.call(print, "body", 0), path.call(print, "body", 1));
-        paramsNode = node.body[3];
-        bodystmtNode = node.body[4];
-        nameDoc = path.call(print, "body", 2);
-        paramsDoc = path.call(print, "body", 3);
-        bodystmtDoc = path.call(print, "body", 4);
-    }
-    // In case there are no parens but there are arguments
-    const parens = paramsNode.type === "params" && paramsNode.body.some((type) => type);
-    declaration.push(nameDoc, parens ? "(" : "", paramsDoc, parens ? ")" : "");
-    if ((0, utils_1.isEmptyBodyStmt)(bodystmtNode)) {
+    // In case there are no parens but there are parameters
+    const useParens = node.params.type === "params" && !(0, utils_1.isEmptyParams)(node.params);
+    declaration.push(path.call(print, "name"), useParens ? "(" : "", path.call(print, "params"), useParens ? ")" : "");
+    if ((0, utils_1.isEmptyBodyStmt)(node.bodystmt)) {
         return group([...declaration, "; end"]);
     }
     return group([
         group(declaration),
-        indent([hardline, bodystmtDoc]),
+        indent([hardline, path.call(print, "bodystmt")]),
         hardline,
         "end"
     ]);
 };
 exports.printDef = printDef;
-const printSingleLineMethod = (path, opts, print) => {
-    const parensNode = path.getValue().body[1];
+const printDefEndless = (path, opts, print) => {
+    const node = path.getValue();
     let paramsDoc = "";
-    if (parensNode) {
-        const paramsNode = parensNode.body[0];
-        if (paramsNode.body.some((type) => type)) {
-            paramsDoc = path.call(print, "body", 1);
-        }
+    // If we have any kind of parameters, we're going to print the whole
+    // parentheses. If we don't, then we're just going to skip them entirely.
+    if (node.paren && !(0, utils_1.isEmptyParams)(node.paren.cnts)) {
+        paramsDoc = path.call(print, "paren");
     }
     return group([
         "def ",
-        path.call(print, "body", 0),
+        path.call(print, "name"),
         paramsDoc,
         " =",
-        indent(group([line, path.call(print, "body", 2)]))
+        indent(group([line, path.call(print, "stmt")]))
     ]);
 };
-exports.printSingleLineMethod = printSingleLineMethod;
-const printAccessControl = (path, opts, print) => {
-    return path.call(print, "body", 0);
-};
+exports.printDefEndless = printDefEndless;
+const printAccessControl = (path, opts, print) => path.call(print, "value");
 exports.printAccessControl = printAccessControl;

data/dist/ruby/nodes/operators.js

@@ -3,29 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printUnary = exports.printDot3 = exports.printDot2 = exports.printBinary = void 0;
+exports.printNot = exports.printUnary = exports.printDot3 = exports.printDot2 = exports.printBinary = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { group, indent, line, softline } = prettier_1.default;
 const printBinary = (path, opts, print) => {
-    const [, operator, rightNode] = path.getValue().body;
-    const space = operator === "**" ? "" : " ";
-    if (utils_1.noIndent.includes(rightNode.type)) {
+    const node = path.getValue();
+    const space = node.op === "**" ? "" : " ";
+    if (utils_1.noIndent.includes(node.right.type)) {
         return group([
-            group(path.call(print, "body", 0)),
+            group(path.call(print, "left")),
             space,
-            operator,
+            node.op,
             space,
-            group(path.call(print, "body", 2))
+            group(path.call(print, "right"))
         ]);
     }
     return group([
-        group(path.call(print, "body", 0)),
+        group(path.call(print, "left")),
         space,
         group(indent([
-            operator,
+            node.op,
             space === "" ? softline : line,
-            path.call(print, "body", 2)
+            path.call(print, "right")
         ]))
     ]);
 };
@@ -33,38 +33,36 @@ exports.printBinary = printBinary;
 // dot2 nodes are used with ranges (or flip-flops). They can optionally drop
 // their left side for beginless ranges or their right side for endless ranges.
 const printDot2 = (path, opts, print) => {
-    const [leftNode, rightNode] = path.getValue().body;
+    const node = path.getValue();
     return [
-        leftNode ? path.call(print, "body", 0) : "",
+        node.left ? path.call(print, "left") : "",
         "..",
-        rightNode ? path.call(print, "body", 1) : ""
+        node.right ? path.call(print, "right") : ""
     ];
 };
 exports.printDot2 = printDot2;
 // dot3 nodes are used with ranges (or flip-flops). They can optionally drop
 // their left side for beginless ranges or their right side for endless ranges.
 const printDot3 = (path, opts, print) => {
-    const [leftNode, rightNode] = path.getValue().body;
+    const node = path.getValue();
     return [
-        leftNode ? path.call(print, "body", 0) : "",
+        node.left ? path.call(print, "left") : "",
         "...",
-        rightNode ? path.call(print, "body", 1) : ""
+        node.right ? path.call(print, "right") : ""
     ];
 };
 exports.printDot3 = printDot3;
 const printUnary = (path, opts, print) => {
     const node = path.getValue();
-    const contentsDoc = path.call(print, "body", 0);
-    if (node.oper === "not") {
-        // Here we defer to the original source, as it's kind of difficult to
-        // determine if we can actually remove the parentheses being used.
-        if (node.paren) {
-            return ["not", "(", contentsDoc, ")"];
-        }
-        else {
-            return ["not", " ", contentsDoc];
-        }
-    }
-    return [node.oper, contentsDoc];
+    return [node.op, path.call(print, "value")];
 };
 exports.printUnary = printUnary;
+const printNot = (path, opts, print) => {
+    const node = path.getValue();
+    const valueDoc = path.call(print, "value");
+    if (node.paren) {
+        return ["not", "(", valueDoc, ")"];
+    }
+    return ["not", " ", valueDoc];
+};
+exports.printNot = printNot;