prettier 2.0.0.pre.rc3 → 2.1.0

data/dist/ruby/nodes/params.js

@@ -3,51 +3,51 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printRestParam = exports.printKeywordRestParam = exports.printArgsForward = exports.printParams = void 0;
+exports.printExcessedComma = exports.printRestParam = exports.printKeywordRestParam = exports.printArgsForward = exports.printParams = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
 const { group, hardline, join, indent, line, lineSuffix, softline } = prettier_1.default;
 function printRestParamSymbol(symbol) {
     return function printRestParamWithSymbol(path, opts, print) {
-        return path.getValue().body[0]
-            ? [symbol, path.call(print, "body", 0)]
-            : symbol;
+        const node = path.getValue();
+        return node.name ? [symbol, path.call(print, "name")] : symbol;
     };
 }
 const printParams = (path, opts, print) => {
-    const [reqs, optls, rest, post, kwargs, kwargRest, block] = path.getValue().body;
+    const node = path.getValue();
     let parts = [];
-    if (reqs) {
+    if (node.reqs) {
         path.each((reqPath) => {
             // For some very strange reason, if you have a comment attached to a
             // rest_param, it shows up here in the list of required params.
             if (reqPath.getValue().type !== "rest_param") {
                 parts.push(print(reqPath));
             }
-        }, "body", 0);
+        }, "reqs");
     }
-    if (optls) {
-        parts = parts.concat(path.map((optlPath) => join(" = ", optlPath.map(print)), "body", 1));
+    if (node.opts) {
+        parts = parts.concat(path.map((optlPath) => join(" = ", optlPath.map(print)), "opts"));
     }
-    if (rest && rest.type !== "excessed_comma") {
-        parts.push(path.call(print, "body", 2));
+    if (node.rest && node.rest.type !== "excessed_comma") {
+        parts.push(path.call(print, "rest"));
     }
-    if (post) {
-        parts = parts.concat(path.map(print, "body", 3));
+    if (node.posts) {
+        parts = parts.concat(path.map(print, "posts"));
     }
-    if (kwargs) {
+    if (node.keywords) {
         parts = parts.concat(path.map((kwargPath) => {
-            if (!kwargPath.getValue()[1]) {
-                return kwargPath.call(print, 0);
+            const kwarg = kwargPath.getValue();
+            const keyDoc = kwargPath.call(print, 0);
+            if (kwarg[1]) {
+                return group([keyDoc, " ", kwargPath.call(print, 1)]);
             }
-            return group(join(" ", kwargPath.map(print)));
-        }, "body", 4));
+            return keyDoc;
+        }, "keywords"));
     }
-    if (kwargRest) {
-        parts.push(kwargRest === "nil" ? "**nil" : path.call(print, "body", 5));
+    if (node.kwrest) {
+        parts.push(node.kwrest === "nil" ? "**nil" : path.call(print, "kwrest"));
     }
-    if (block) {
-        parts.push(path.call(print, "body", 6));
+    if (node.block) {
+        parts.push(path.call(print, "block"));
     }
     const contents = [join([",", line], parts)];
     // You can put an extra comma at the end of block args between pipes to
@@ -59,7 +59,8 @@ const printParams = (path, opts, print) => {
     // In ruby 2.5, the excessed comma is indicated by having a 0 in the rest
     // param position. In ruby 2.6+ it's indicated by having an "excessed_comma"
     // node in the rest position. Seems odd, but it's true.
-    if (rest === 0 || (rest && rest.type === "excessed_comma")) {
+    if (node.rest === 0 ||
+        (node.rest && node.rest.type === "excessed_comma")) {
         contents.push(",");
     }
     // If the parent node is a paren then we skipped printing the parentheses so
@@ -84,6 +85,11 @@ const printParams = (path, opts, print) => {
     return group(contents);
 };
 exports.printParams = printParams;
-exports.printArgsForward = (0, utils_1.literal)("...");
+const printArgsForward = (path) => path.getValue().value;
+exports.printArgsForward = printArgsForward;
 exports.printKeywordRestParam = printRestParamSymbol("**");
 exports.printRestParam = printRestParamSymbol("*");
+const printExcessedComma = (path, opts, print) => {
+    return path.call(print, "value");
+};
+exports.printExcessedComma = printExcessedComma;

data/dist/ruby/nodes/patterns.js

@@ -18,48 +18,60 @@ const printPatternArg = (path, opts, print) => {
     return path.call(print);
 };
 const printAryPtn = (path, opts, print) => {
-    const [constant, preargs, splatarg, postargs] = path.getValue().body;
-    let args = [];
-    if (preargs) {
-        args = args.concat(path.map((argPath) => printPatternArg(argPath, opts, print), "body", 1));
+    const node = path.getValue();
+    let argDocs = [];
+    if (node.reqs.length > 0) {
+        argDocs = argDocs.concat(path.map((argPath) => printPatternArg(argPath, opts, print), "reqs"));
     }
-    if (splatarg) {
-        args.push(["*", path.call(print, "body", 2)]);
+    if (node.rest) {
+        argDocs.push(["*", path.call(print, "rest")]);
     }
-    if (postargs) {
-        args = args.concat(path.map(print, "body", 3));
+    if (node.posts.length > 0) {
+        argDocs = argDocs.concat(path.map(print, "posts"));
     }
-    args = group(join([",", line], args));
-    if (constant || patterns.includes(path.getParentNode().type)) {
-        args = ["[", args, "]"];
+    let argDoc = group(join([",", line], argDocs));
+    // There are a couple of cases where we _must_ use brackets. They include:
+    //
+    // * When the number of arguments inside the array pattern is one 1, then we
+    //   have to include them, otherwise it matches the whole array. Consider the
+    //   difference between `in [elem]` and `in elem`.
+    // * If we have a wrapping constant, then we definitely need the brackets.
+    //   Consider the difference between `in Const[elem]` and `in Const elem`
+    // * If we're nested inside a parent pattern, then we have to have brackets.
+    //   Consider the difference between `in key: first, second` and
+    //   `in key: [first, second]`.
+    if (argDocs.length === 1 ||
+        node.constant ||
+        patterns.includes(path.getParentNode().type)) {
+        argDoc = ["[", argDoc, "]"];
     }
-    if (constant) {
-        return [path.call(print, "body", 0), args];
+    if (node.constant) {
+        return [path.call(print, "constant"), argDoc];
     }
-    return args;
+    return argDoc;
 };
 exports.printAryPtn = printAryPtn;
 const printFndPtn = (path, opts, print) => {
-    const [constant] = path.getValue().body;
+    const node = path.getValue();
     const docs = [
         "[",
         group(join([",", line], [
-            ["*", path.call(print, "body", 1)],
-            ...path.map(print, "body", 2),
-            ["*", path.call(print, "body", 3)]
+            ["*", path.call(print, "left")],
+            ...path.map(print, "values"),
+            ["*", path.call(print, "right")]
         ])),
         "]"
     ];
-    if (constant) {
-        return [path.call(print, "body", 0), docs];
+    if (node.constant) {
+        return [path.call(print, "constant"), docs];
     }
     return docs;
 };
 exports.printFndPtn = printFndPtn;
 const printHshPtn = (path, opts, print) => {
-    const [constant, keyValuePairs, keyValueRest] = path.getValue().body;
+    const node = path.getValue();
     let args = [];
-    if (keyValuePairs.length > 0) {
+    if (node.keywords.length > 0) {
         const printPair = (pairPath) => {
             const parts = [pairPath.call(print, 0)];
             if (pairPath.getValue()[1]) {
@@ -67,43 +79,41 @@ const printHshPtn = (path, opts, print) => {
             }
             return parts;
         };
-        args = args.concat(path.map(printPair, "body", 1));
+        args = args.concat(path.map(printPair, "keywords"));
     }
-    if (keyValueRest) {
-        args.push(["**", path.call(print, "body", 2)]);
+    if (node.kwrest) {
+        args.push(["**", path.call(print, "kwrest")]);
     }
     args = group(join([",", line], args));
-    if (constant) {
+    if (node.constant) {
         args = ["[", args, "]"];
     }
     else if (patterns.includes(path.getParentNode().type)) {
         args = ["{ ", args, " }"];
     }
-    if (constant) {
-        return [path.call(print, "body", 0), args];
+    if (node.constant) {
+        return [path.call(print, "constant"), args];
     }
     return args;
 };
 exports.printHshPtn = printHshPtn;
 const printIn = (path, opts, print) => {
+    const keyword = "in ";
     const parts = [
-        "in ",
-        align("in ".length, path.call((valuePath) => printPatternArg(valuePath, opts, print), "body", 0)),
-        indent([hardline, path.call(print, "body", 1)])
+        keyword,
+        align(keyword.length, path.call((valuePath) => printPatternArg(valuePath, opts, print), "pattern")),
+        indent([hardline, path.call(print, "stmts")])
     ];
-    if (path.getValue().body[2]) {
-        parts.push(hardline, path.call(print, "body", 2));
+    if (path.getValue().cons) {
+        parts.push(hardline, path.call(print, "cons"));
     }
     return group(parts);
 };
 exports.printIn = printIn;
-const printRAssign = (path, opts, print) => {
-    const { keyword } = path.getValue();
-    const [leftDoc, rightDoc] = path.map(print, "body");
-    return group([
-        leftDoc,
-        keyword ? " in" : " =>",
-        group(indent([line, rightDoc]))
-    ]);
-};
+const printRAssign = (path, opts, print) => group([
+    path.call(print, "value"),
+    " ",
+    path.call(print, "op"),
+    group(indent([line, path.call(print, "pattern")]))
+]);
 exports.printRAssign = printRAssign;

data/dist/ruby/nodes/regexp.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.printRegexpLiteral = void 0;
 const utils_1 = require("../../utils");
 function hasContent(node, pattern) {
-    return node.body.some((child) => child.type === "@tstring_content" && pattern.test(child.body));
+    return node.parts.some((part) => part.type === "tstring_content" && pattern.test(part.value));
 }
 // If the first part of this regex is plain string content, we have a space
 // or an =, and we're contained within a command or command_call node, then we
@@ -11,10 +11,10 @@ function hasContent(node, pattern) {
 // operator, e.g. foo / bar/ or foo /=bar/
 function forwardSlashIsAmbiguous(path) {
     const node = path.getValue();
-    const firstChildNode = node.body[0];
-    return (firstChildNode &&
-        firstChildNode.type === "@tstring_content" &&
-        [" ", "="].includes(firstChildNode.body[0]) &&
+    const firstPart = node.parts[0];
+    return (firstPart &&
+        firstPart.type === "tstring_content" &&
+        [" ", "="].includes(firstPart.value[0]) &&
         (0, utils_1.hasAncestor)(path, ["command", "command_call"]));
 }
 // This function is responsible for printing out regexp_literal nodes. They can
@@ -26,7 +26,7 @@ function forwardSlashIsAmbiguous(path) {
 // itself. In that case we switch over to using %r with braces.
 const printRegexpLiteral = (path, opts, print) => {
     const node = path.getValue();
-    const docs = path.map(print, "body");
+    const docs = path.map(print, "parts");
     // We should use braces if using a forward slash would be ambiguous in the
     // current context or if there's a forward slash in the content of the regexp.
     const useBraces = forwardSlashIsAmbiguous(path) || hasContent(node, /\//);

data/dist/ruby/nodes/rescue.js

@@ -5,12 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printRetry = exports.printRedo = exports.printRescueMod = exports.printRescueEx = exports.printRescue = exports.printEnsure = exports.printBegin = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
 const { align, group, hardline, indent, join, line } = prettier_1.default;
 const printBegin = (path, opts, print) => {
     return [
         "begin",
-        indent([hardline, path.map(print, "body")]),
+        indent([hardline, path.call(print, "bodystmt")]),
         hardline,
         "end"
     ];
@@ -18,15 +17,16 @@ const printBegin = (path, opts, print) => {
 exports.printBegin = printBegin;
 const printEnsure = (path, opts, print) => {
     return [
-        path.call(print, "body", 0),
-        indent([hardline, path.call(print, "body", 1)])
+        path.call(print, "keyword"),
+        indent([hardline, path.call(print, "stmts")])
     ];
 };
 exports.printEnsure = printEnsure;
 const printRescue = (path, opts, print) => {
+    const node = path.getValue();
     const parts = ["rescue"];
-    if (path.getValue().body[0]) {
-        parts.push(align("rescue ".length, path.call(print, "body", 0)));
+    if (node.extn) {
+        parts.push(align("rescue ".length, path.call(print, "extn")));
     }
     else {
         // If you don't specify an error to rescue in a `begin/rescue` block, then
@@ -34,14 +34,14 @@ const printRescue = (path, opts, print) => {
         // just going to explicitly add it.
         parts.push(" StandardError");
     }
-    const bodystmt = path.call(print, "body", 1);
-    if (bodystmt.length > 0) {
-        parts.push(indent([hardline, bodystmt]));
+    const stmtsDoc = path.call(print, "stmts");
+    if (stmtsDoc.length > 0) {
+        parts.push(indent([hardline, stmtsDoc]));
     }
     // This is the next clause on the `begin` statement, either another
     // `rescue`, and `ensure`, or an `else` clause.
-    if (path.getValue().body[2]) {
-        parts.push([hardline, path.call(print, "body", 2)]);
+    if (node.cons) {
+        parts.push([hardline, path.call(print, "cons")]);
     }
     return group(parts);
 };
@@ -49,34 +49,38 @@ exports.printRescue = printRescue;
 // This is a container node that we're adding into the AST that isn't present in
 // Ripper solely so that we have a nice place to attach inline comments.
 const printRescueEx = (path, opts, print) => {
-    const [exception, variable] = path.getValue().body;
+    const node = path.getValue();
     const parts = [];
-    if (exception) {
-        let exceptionDoc = path.call(print, "body", 0);
-        if (Array.isArray(exceptionDoc)) {
-            const joiner = [",", line];
-            exceptionDoc = group(join(joiner, exceptionDoc));
+    if (node.extns) {
+        // If there's just one exception being rescued, then it's just going to be a
+        // single doc node.
+        let exceptionDoc = path.call(print, "extns");
+        // If there are multiple exceptions being rescued, then we're going to have
+        // multiple doc nodes returned as an array that we need to join together.
+        if (["mrhs", "mrhs_add_star", "mrhs_new_from_args"].includes(node.extns.type)) {
+            exceptionDoc = group(join([",", line], exceptionDoc));
         }
         parts.push(" ", exceptionDoc);
     }
-    if (variable) {
-        parts.push(" => ", path.call(print, "body", 1));
+    if (node.var) {
+        parts.push(" => ", path.call(print, "var"));
     }
     return group(parts);
 };
 exports.printRescueEx = printRescueEx;
 const printRescueMod = (path, opts, print) => {
-    const [statementDoc, valueDoc] = path.map(print, "body");
     return [
         "begin",
-        indent([hardline, statementDoc]),
+        indent([hardline, path.call(print, "stmt")]),
         hardline,
         "rescue StandardError",
-        indent([hardline, valueDoc]),
+        indent([hardline, path.call(print, "value")]),
         hardline,
         "end"
     ];
 };
 exports.printRescueMod = printRescueMod;
-exports.printRedo = (0, utils_1.literal)("redo");
-exports.printRetry = (0, utils_1.literal)("retry");
+const printRedo = (path) => path.getValue().value;
+exports.printRedo = printRedo;
+const printRetry = (path) => path.getValue().value;
+exports.printRetry = printRetry;

data/dist/ruby/nodes/return.js

@@ -5,12 +5,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printReturn0 = exports.printReturn = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
 const { group, ifBreak, indent, line, join, softline } = prettier_1.default;
 // You can't skip the parentheses if you have comments or certain operators with
 // lower precedence than the return keyword.
-function canSkipParens(args) {
-    const stmts = args.body[0].body[0];
+function canSkipParens(paren) {
+    const stmts = paren.cnts;
+    // return(
+    //   foo
+    //   bar
+    // )
+    if (stmts.body.length !== 1) {
+        return false;
+    }
     // return(
     //   # a
     //   b
@@ -20,49 +26,67 @@ function canSkipParens(args) {
     }
     const stmt = stmts.body[0];
     // return (a or b)
-    if (stmt.type === "binary" && ["and", "or"].includes(stmt.body[1])) {
+    if (stmt.type === "binary" && ["and", "or"].includes(stmt.op)) {
         return false;
     }
     // return (not a)
-    if (stmt.type === "unary" && stmt.oper === "not") {
+    if (stmt.type === "not") {
         return false;
     }
     return true;
 }
 const printReturn = (path, opts, print) => {
-    let args = path.getValue().body[0].body[0];
-    let steps = ["body", 0, "body", 0];
-    if (args.body.length === 1) {
-        // If the body of the return contains parens, then just skip directly to the
-        // content of the parens so that we can skip printing parens if we don't
-        // want them.
-        if (args.body[0] && args.body[0].type === "paren" && canSkipParens(args)) {
-            args = args.body[0].body[0];
-            steps = steps.concat("body", 0, "body", 0);
-        }
-        // If we're returning an array literal that isn't a special array, single
-        // element array, or an empty array, then we want to grab the arguments so
-        // that we can print them out as if they were normal return arguments.
-        if (args.body[0] &&
-            args.body[0].type === "array" &&
-            args.body[0].body[0] &&
-            args.body[0].body[0].body.length > 1 &&
-            ["args", "args_add_star"].includes(args.body[0].body[0].type)) {
-            steps = steps.concat("body", 0, "body", 0);
+    const node = path.getValue();
+    let parts = "";
+    let joining = false;
+    if (node.args.type === "args_add_block") {
+        const args = node.args.args;
+        const steps = ["args", "args"];
+        if (args.type === "args" && args.parts.length === 1 && args.parts[0]) {
+            // This is the first and only argument being passed to the return keyword.
+            let arg = args.parts[0];
+            steps.push("parts", 0);
+            // If the body of the return contains parens, then just skip directly to
+            // the content of the parens so that we can skip printing parens if we
+            // don't want them.
+            if (arg.type === "paren") {
+                // If we can't skip over the parentheses, then we know we can just bail
+                // out here and print the only argument as normal since it's a paren.
+                if (!canSkipParens(arg)) {
+                    return ["return", path.call(print, "args")];
+                }
+                arg = arg.cnts.body[0];
+                steps.push("cnts", "body", 0);
+            }
+            // If we're returning an array literal that isn't a special array that has
+            // at least 2 elements, then we want to grab the arguments so that we can
+            // print them out as if they were normal return arguments.
+            if (arg.type === "array" && arg.cnts) {
+                const contents = arg.cnts;
+                if (contents.type === "args" && contents.parts.length > 1) {
+                    // If we have just regular arguments and we have more than 1.
+                    steps.push("cnts");
+                }
+            }
         }
+        // We're doing this weird dance with the steps variable because it's
+        // possible that you're printing an array nested under some parentheses, in
+        // which case we still want to descend down that far. For example,
+        // return([1, 2, 3]) should print as return 1, 2, 3.
+        parts = path.call((targetPath) => {
+            const target = targetPath.getValue();
+            joining = target.type === "args" || target.type === "args_add_block";
+            return print(targetPath);
+        }, ...steps);
     }
-    // Now that we've established which actual node is the arguments to return,
-    // we grab it out of the path by diving down the steps that we've set up.
-    const parts = path.call(print, ...steps);
-    const useBrackets = Array.isArray(parts) && parts.length > 1;
-    // If we got the value straight out of the parens, then `parts` would only
-    // be a singular doc as opposed to an array.
-    const value = Array.isArray(parts) ? join([",", line], parts) : parts;
-    // We only get here if we have comments somewhere that would prevent us from
-    // skipping the parentheses.
-    if (args.body.length === 1 && args.body[0].type === "paren") {
-        return ["return", value];
+    // If we didn't hit any of our special cases, then just print out the
+    // arguments normally here.
+    if (parts === "") {
+        parts = path.call(print, "args");
+        joining = true;
     }
+    const useBrackets = Array.isArray(parts) && parts.length > 1;
+    const value = joining ? join([",", line], parts) : parts;
     return group([
         "return",
         ifBreak(useBrackets ? " [" : "(", " "),
@@ -72,4 +96,5 @@ const printReturn = (path, opts, print) => {
     ]);
 };
 exports.printReturn = printReturn;
-exports.printReturn0 = (0, utils_1.literal)("return");
+const printReturn0 = (path) => path.getValue().value;
+exports.printReturn0 = printReturn0;

data/dist/ruby/nodes/statements.js

@@ -3,40 +3,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printStmts = exports.printProgram = exports.printComment = exports.printEndContent = exports.printParen = exports.printBodyStmt = void 0;
+exports.printStatements = exports.printProgram = exports.printComment = exports.printEndContent = exports.printParen = exports.printBodyStmt = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
+const location_1 = require("../location");
 const { breakParent, dedent, group, hardline, indent, join, line, literalline, softline, trim } = prettier_1.default;
 const printBodyStmt = (path, opts, print) => {
-    const [stmts, rescue, elseClause, ensure] = path.getValue().body;
+    const node = path.getValue();
     const parts = [];
-    if (!(0, utils_1.isEmptyStmts)(stmts)) {
-        parts.push(path.call(print, "body", 0));
+    if (!(0, utils_1.isEmptyStmts)(node.stmts)) {
+        parts.push(path.call(print, "stmts"));
     }
-    if (rescue) {
-        parts.push(dedent([hardline, path.call(print, "body", 1)]));
+    if (node.rsc) {
+        parts.push(dedent([hardline, path.call(print, "rsc")]));
     }
-    if (elseClause) {
+    if (node.els) {
         // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
         /* istanbul ignore next */
-        const stmts = elseClause.type === "else"
-            ? path.call(print, "body", 2, "body", 0)
-            : path.call(print, "body", 2);
+        const stmts = node.els.type === "else"
+            ? path.call(print, "els", "body", 0)
+            : path.call(print, "els");
         parts.push([dedent([hardline, "else"]), hardline, stmts]);
     }
-    if (ensure) {
-        parts.push(dedent([hardline, path.call(print, "body", 3)]));
+    if (node.ens) {
+        parts.push(dedent([hardline, path.call(print, "ens")]));
     }
     return group(parts);
 };
 exports.printBodyStmt = printBodyStmt;
-const argNodeTypes = ["args", "args_add_star", "args_add_block"];
+const argNodeTypes = ["args", "args_add_block"];
 const printParen = (path, opts, print) => {
-    const contentNode = path.getValue().body[0];
+    const contentNode = path.getValue().cnts;
     if (!contentNode) {
         return [path.call(print, "lparen"), ")"];
     }
-    let contentDoc = path.call(print, "body", 0);
+    let contentDoc = path.call(print, "cnts");
     // If the content is params, we're going to let it handle its own parentheses
     // so that it breaks nicely.
     if (contentNode.type === "params") {
@@ -56,19 +57,17 @@ const printParen = (path, opts, print) => {
 };
 exports.printParen = printParen;
 const printEndContent = (path) => {
-    const { body } = path.getValue();
-    return [trim, "__END__", literalline, body];
+    const node = path.getValue();
+    return [trim, "__END__", literalline, node.value];
 };
 exports.printEndContent = printEndContent;
 const printComment = (path, opts) => {
     return opts.printer.printComment(path, opts);
 };
 exports.printComment = printComment;
-const printProgram = (path, opts, print) => {
-    return [join(hardline, path.map(print, "body")), hardline];
-};
+const printProgram = (path, opts, print) => [path.call(print, "stmts"), hardline];
 exports.printProgram = printProgram;
-const printStmts = (path, opts, print) => {
+const printStatements = (path, opts, print) => {
     const stmts = path.getValue().body;
     // This is a special case where we have only comments inside a statement
     // list. In this case we want to avoid doing any kind of line number
@@ -93,19 +92,19 @@ const printStmts = (path, opts, print) => {
         if (lineNo === null) {
             parts.push(printed);
         }
-        else if (stmt.sl - lineNo > 1 ||
+        else if ((0, location_1.getStartLine)(stmt.loc) - lineNo > 1 ||
             [stmt.type, stmts[index - 1].type].includes("access_ctrl")) {
             parts.push(hardline, hardline, printed);
         }
-        else if (stmt.sl !== lineNo ||
+        else if ((0, location_1.getStartLine)(stmt.loc) !== lineNo ||
             path.getParentNode().type !== "string_embexpr") {
             parts.push(hardline, printed);
         }
         else {
             parts.push("; ", printed);
         }
-        lineNo = stmt.el;
+        lineNo = (0, location_1.getEndLine)(stmt.loc);
     });
     return parts;
 };
-exports.printStmts = printStmts;
+exports.printStatements = printStatements;