prettier 0.22.0 → 1.1.0

data/src/nodes/methods.js

@@ -28,7 +28,9 @@ function printMethod(offset) {
 
     // If the body is empty, we can replace with a ;
     const stmts = body.body[0].body;
+
     if (
+      !body.body.slice(1).some((node) => node) &&
       stmts.length === 1 &&
       stmts[0].type === "void_stmt" &&
       !stmts[0].comments

data/src/nodes/operators.js

@@ -1,23 +1,34 @@
 const { concat, group, indent, line, softline } = require("../prettier");
+const { noIndent } = require("../utils");
 
 function printBinary(path, opts, print) {
-  const operator = path.getValue().body[1];
-  const useNoSpace = operator === "**";
+  const [_leftNode, operator, rightNode] = path.getValue().body;
+  const space = operator === "**" ? "" : " ";
+
+  if (noIndent.includes(rightNode.type)) {
+    return group(
+      concat([
+        group(path.call(print, "body", 0)),
+        space,
+        operator,
+        space,
+        group(path.call(print, "body", 2))
+      ])
+    );
+  }
 
   return group(
     concat([
       group(path.call(print, "body", 0)),
-      indent(
-        concat([
-          useNoSpace ? "" : " ",
-          group(
-            concat([
-              operator,
-              useNoSpace ? softline : line,
-              path.call(print, "body", 2)
-            ])
-          )
-        ])
+      space,
+      group(
+        indent(
+          concat([
+            operator,
+            space === "" ? softline : line,
+            path.call(print, "body", 2)
+          ])
+        )
       )
     ])
   );

data/src/nodes/params.js

@@ -1,4 +1,4 @@
-const { concat, group, join, line } = require("../prettier");
+const { concat, group, join, indent, line, softline } = require("../prettier");
 const { literal } = require("../utils");
 
 function printRestParam(symbol) {
@@ -64,6 +64,8 @@ function printParams(path, opts, print) {
     parts.push(path.call(print, "body", 6));
   }
 
+  const contents = [join(concat([",", line]), parts)];
+
   // You can put an extra comma at the end of block args between pipes to
   // change what it does. Below is the difference:
   //
@@ -73,9 +75,19 @@ function 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.
-  const comma = rest === 0 || (rest && rest.type === "excessed_comma");
+  if (rest === 0 || (rest && rest.type === "excessed_comma")) {
+    contents.push(",");
+  }
+
+  // If the parent node is a paren then we skipped printing the parentheses so
+  // that we could handle them here and get nicer formatting.
+  if (["lambda", "paren"].includes(path.getParentNode().type)) {
+    return group(
+      concat(["(", indent(concat([softline].concat(contents))), softline, ")"])
+    );
+  }
 
-  return group(concat([join(concat([",", line]), parts), comma ? "," : ""]));
+  return group(concat(contents));
 }
 
 module.exports = {

data/src/nodes/regexp.js

@@ -1,4 +1,27 @@
 const { concat } = require("../prettier");
+const { hasAncestor } = require("../utils");
+
+function hasContent(node, pattern) {
+  return node.body.some(
+    (child) => child.type === "@tstring_content" && pattern.test(child.body)
+  );
+}
+
+// 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
+// want to use braces because otherwise we could end up with an ambiguous
+// 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]) &&
+    hasAncestor(path, ["command", "command_call"])
+  );
+}
 
 // This function is responsible for printing out regexp_literal nodes. They can
 // either use the special %r literal syntax or they can use forward slashes. At
@@ -8,18 +31,24 @@ const { concat } = require("../prettier");
 // We favor the use of forward slashes unless the regex contains a forward slash
 // itself. In that case we switch over to using %r with braces.
 function printRegexpLiteral(path, opts, print) {
-  const { ending } = path.getValue();
-  const contents = path.map(print, "body");
+  const node = path.getValue();
+  const docs = path.map(print, "body");
 
-  const useBraces = contents.some(
-    (content) => typeof content === "string" && content.includes("/")
-  );
+  // 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, /\//);
 
-  const parts = [useBraces ? "%r{" : "/"]
-    .concat(contents)
-    .concat([useBraces ? "}" : "/", ending.slice(1)]);
+  // If we should be using braces but we have braces in the body of the regexp,
+  // then we're just going to resort to using whatever the original content was.
+  if (useBraces && hasContent(node, /[{}]/)) {
+    return concat([node.beging].concat(docs).concat(node.ending));
+  }
 
-  return concat(parts);
+  return concat(
+    [useBraces ? "%r{" : "/"]
+      .concat(docs)
+      .concat(useBraces ? "}" : "/", node.ending.slice(1))
+  );
 }
 
 module.exports = {

data/src/nodes/rescue.js

@@ -20,8 +20,8 @@ function printBegin(path, opts, print) {
 
 function printEnsure(path, opts, print) {
   return concat([
-    "ensure",
-    indent(concat([hardline, concat(path.map(print, "body"))]))
+    path.call(print, "body", 0),
+    indent(concat([hardline, path.call(print, "body", 1)]))
   ]);
 }
 

data/src/nodes/statements.js

@@ -12,58 +12,78 @@ const {
   trim
 } = require("../prettier");
 
-module.exports = {
-  "@__end__": (path, _opts, _print) => {
-    const { body } = path.getValue();
-    return concat([trim, "__END__", literalline, body]);
-  },
-  bodystmt: (path, opts, print) => {
-    const [_statements, rescue, elseClause, ensure] = path.getValue().body;
-    const parts = [path.call(print, "body", 0)];
+function printBodyStmt(path, opts, print) {
+  const [stmts, rescue, elseClause, ensure] = path.getValue().body;
+  const parts = [];
+
+  if (
+    stmts.body.length > 1 ||
+    stmts.body[0].type != "void_stmt" ||
+    stmts.body[0].comments
+  ) {
+    parts.push(path.call(print, "body", 0));
+  }
 
-    if (rescue) {
-      parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
-    }
+  if (rescue) {
+    parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
+  }
 
-    if (elseClause) {
-      // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
-      const stmts =
-        elseClause.type === "else"
-          ? path.call(print, "body", 2, "body", 0)
-          : path.call(print, "body", 2);
+  if (elseClause) {
+    // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
+    const stmts =
+      elseClause.type === "else"
+        ? path.call(print, "body", 2, "body", 0)
+        : path.call(print, "body", 2);
 
-      parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
-    }
+    parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
+  }
 
-    if (ensure) {
-      parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
-    }
+  if (ensure) {
+    parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
+  }
 
-    return group(concat(parts));
-  },
-  paren: (path, opts, print) => {
-    if (!path.getValue().body[0]) {
-      return "()";
-    }
+  return group(concat(parts));
+}
 
-    let content = path.call(print, "body", 0);
+const argNodeTypes = ["args", "args_add_star", "args_add_block"];
 
-    if (
-      ["args", "args_add_star", "args_add_block"].includes(
-        path.getValue().body[0].type
-      )
-    ) {
-      content = join(concat([",", line]), content);
-    }
+function printParen(path, opts, print) {
+  const contentNode = path.getValue().body[0];
+
+  if (!contentNode) {
+    return "()";
+  }
+
+  let contentDoc = path.call(print, "body", 0);
+
+  // If the content is params, we're going to let it handle its own parentheses
+  // so that it breaks nicely.
+  if (contentNode.type === "params") {
+    return contentDoc;
+  }
 
-    return group(
-      concat([
-        "(",
-        indent(concat([softline, content])),
-        concat([softline, ")"])
-      ])
-    );
+  // If we have an arg type node as the contents, then it's going to return an
+  // array, so we need to explicitly join that content here.
+  if (argNodeTypes.includes(contentNode.type)) {
+    contentDoc = join(concat([",", line]), contentDoc);
+  }
+
+  return group(
+    concat([
+      "(",
+      indent(concat([softline, contentDoc])),
+      concat([softline, ")"])
+    ])
+  );
+}
+
+module.exports = {
+  "@__end__": (path, _opts, _print) => {
+    const { body } = path.getValue();
+    return concat([trim, "__END__", literalline, body]);
   },
+  bodystmt: printBodyStmt,
+  paren: printParen,
   program: (path, opts, print) =>
     concat([join(hardline, path.map(print, "body")), hardline]),
   stmts: (path, opts, print) => {
@@ -78,8 +98,8 @@ module.exports = {
       stmts[0].comments
     ) {
       const comments = path.map(
-        (commentPath, index) => {
-          stmts[0].comments[index].printed = true;
+        (commentPath) => {
+          commentPath.getValue().printed = true;
           return opts.printer.printComment(commentPath);
         },
         "body",

data/src/nodes/strings.js

@@ -32,7 +32,7 @@ function isSingleQuotable(node) {
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
 
 function normalizeQuotes(content, enclosingQuote, originalQuote) {
-  const replaceOther = ["'", '"'].includes(originalQuote);
+  const replaceOther = originalQuote === '"';
   const otherQuote = enclosingQuote === '"' ? "'" : '"';
 
   // Escape and unescape single and double quotes as needed to be able to
@@ -66,7 +66,7 @@ function getClosingQuote(quote) {
     return quote;
   }
 
-  const boundary = /%q?(.)/.exec(quote)[1];
+  const boundary = /%[Qq]?(.)/.exec(quote)[1];
   if (boundary in quotePairs) {
     return quotePairs[boundary];
   }
@@ -77,14 +77,14 @@ function getClosingQuote(quote) {
 // Prints a @CHAR node. @CHAR nodes are special character strings that usually
 // are strings of length 1. If they're any longer than we'll try to apply the
 // correct quotes.
-function printChar(path, { preferSingleQuotes }, _print) {
+function printChar(path, { rubySingleQuote }, _print) {
   const { body } = path.getValue();
 
   if (body.length !== 2) {
     return body;
   }
 
-  const quote = preferSingleQuotes ? "'" : '"';
+  const quote = rubySingleQuote ? "'" : '"';
   return concat([quote, body.slice(1), quote]);
 }
 
@@ -107,13 +107,13 @@ function printStringDVar(path, opts, print) {
 // wishes of the user with regards to single versus double quotes, but if the
 // string contains any escape expressions then it will just keep the original
 // quotes.
-function printStringLiteral(path, { preferSingleQuotes }, print) {
+function printStringLiteral(path, { rubySingleQuote }, print) {
   const node = path.getValue();
 
   // If the string is empty, it will not have any parts, so just print out the
   // quotes corresponding to the config
   if (node.body.length === 0) {
-    return preferSingleQuotes ? "''" : '""';
+    return rubySingleQuote ? "''" : '""';
   }
 
   // Determine the quote that should enclose the new string
@@ -121,7 +121,7 @@ function printStringLiteral(path, { preferSingleQuotes }, print) {
   if (isQuoteLocked(node)) {
     quote = node.quote;
   } else {
-    quote = preferSingleQuotes && isSingleQuotable(node) ? "'" : '"';
+    quote = rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
   }
 
   const parts = node.body.map((part, index) => {
@@ -167,10 +167,11 @@ module.exports = {
   string_embexpr: (path, opts, print) => {
     const parts = path.call(print, "body", 0);
 
-    // If the interpolated expression is inside of an xstring literal (a string
-    // that gets sent to the command line) then we don't want to automatically
-    // indent, as this can lead to some very odd looking expressions
-    if (path.getParentNode().type === "xstring_literal") {
+    // If the interpolated expression is inside of a heredoc or an xstring
+    // literal (a string that gets sent to the command line) then we don't want
+    // to automatically indent, as this can lead to some very odd looking
+    // expressions
+    if (["heredoc", "xstring_literal"].includes(path.getParentNode().type)) {
       return concat(["#{", parts, "}"]);
     }
 

data/src/parser.js

@@ -3,18 +3,33 @@ const path = require("path");
 
 // In order to properly parse ruby code, we need to tell the ruby process to
 // parse using UTF-8. Unfortunately, the way that you accomplish this looks
-// differently depending on your platform. This object below represents all of
-// the possible values of process.platform per:
-//   https://nodejs.org/api/process.html#process_process_platform
-const LANG = {
-  aix: "C.UTF-8",
-  darwin: "en_US.UTF-8",
-  freebsd: "C.UTF-8",
-  linux: "C.UTF-8",
-  openbsd: "C.UTF-8",
-  sunos: "C.UTF-8",
-  win32: ".UTF-8"
-}[process.platform];
+// differently depending on your platform.
+const LANG = (() => {
+  const { env, platform } = process;
+  const envValue = env.LC_ALL || env.LC_CTYPE || env.LANG;
+
+  // If an env var is set for the locale that already includes UTF-8 in the
+  // name, then assume we can go with that.
+  if (envValue && envValue.includes("UTF-8")) {
+    return envValue;
+  }
+
+  // Otherwise, we're going to guess which encoding to use based on the system.
+  // This is probably not the best approach in the world, as you could be on
+  // linux and not have C.UTF-8, but in that case you're probably passing an env
+  // var for it. This object below represents all of the possible values of
+  // process.platform per:
+  // https://nodejs.org/api/process.html#process_process_platform
+  return {
+    aix: "C.UTF-8",
+    darwin: "en_US.UTF-8",
+    freebsd: "C.UTF-8",
+    linux: "C.UTF-8",
+    openbsd: "C.UTF-8",
+    sunos: "C.UTF-8",
+    win32: ".UTF-8"
+  }[platform];
+})();
 
 // This function is responsible for taking an input string of text and returning
 // to prettier a JavaScript object that is the equivalent AST that represents

data/src/parser.rb

@@ -2,7 +2,7 @@
 
 # We implement our own version checking here instead of using Gem::Version so
 # that we can use the --disable-gems flag.
-RUBY_MAJOR, RUBY_MINOR, * = RUBY_VERSION.split('.').map(&:to_i)
+RUBY_MAJOR, RUBY_MINOR, RUBY_PATCH, * = RUBY_VERSION.split('.').map(&:to_i)
 
 if (RUBY_MAJOR < 2) || ((RUBY_MAJOR == 2) && (RUBY_MINOR < 5))
   warn(
@@ -115,15 +115,14 @@ class Prettier::Parser < Ripper
   # This will break everything, so we need to force the encoding back into
   # UTF-8 so that the JSON library won't break.
   def on_comment(value)
-    @comments <<
-      {
-        type: :@comment,
-        value: value[1..-1].chomp.force_encoding('UTF-8'),
-        start: lineno,
-        end: lineno,
-        char_start: char_pos,
-        char_end: char_pos + value.length - 1
-      }
+    @comments << {
+      type: :@comment,
+      value: value[1..-1].chomp.force_encoding('UTF-8'),
+      start: lineno,
+      end: lineno,
+      char_start: char_pos,
+      char_end: char_pos + value.length - 1
+    }
   end
 
   # ignored_nl is a special kind of scanner event that passes nil as the value,
@@ -187,11 +186,14 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@lbrace)
     ending = find_scanner_event(:@rbrace)
 
-    stmts.bind(beging[:char_end], ending[:char_start])
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
 
     find_scanner_event(:@kw, 'BEGIN').merge!(
       type: :BEGIN,
-      body: [stmts],
+      body: [beging, stmts],
       end: ending[:end],
       char_end: ending[:char_end]
     )
@@ -211,10 +213,16 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@lbrace)
     ending = find_scanner_event(:@rbrace)
 
-    stmts.bind(beging[:char_end], ending[:char_start])
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
 
     find_scanner_event(:@kw, 'END').merge!(
-      type: :END, body: [stmts], end: ending[:end], char_end: ending[:char_end]
+      type: :END,
+      body: [beging, stmts],
+      end: ending[:end],
+      char_end: ending[:char_end]
     )
   end
 
@@ -306,7 +314,9 @@ class Prettier::Parser < Ripper
       arg.merge(type: :args, body: [arg])
     else
       args.merge!(
-        body: args[:body] << arg, end: arg[:end], char_end: arg[:char_end]
+        body: args[:body] << arg,
+        end: arg[:end],
+        char_end: arg[:char_end]
       )
     end
   end
@@ -352,7 +362,12 @@ class Prettier::Parser < Ripper
   # method inside a set of parentheses.
   def on_arg_paren(args)
     beging = find_scanner_event(:@lparen)
-    ending = find_scanner_event(:@rparen)
+    rparen = find_scanner_event(:@rparen)
+
+    # If the arguments exceed the ending of the parentheses, then we know we
+    # have a heredoc in the arguments, and we need to use the bounds of the
+    # arguments to determine how large the arg_paren is.
+    ending = (args && args[:end] > rparen[:end]) ? args : rparen
 
     {
       type: :arg_paren,
@@ -553,13 +568,15 @@ class Prettier::Parser < Ripper
 
       # Here we're going to determine the bounds for the stmts
       consequent = parts[1..-1].compact.first
-      self[:body][0].bind(char_start,
-        consequent ? consequent[:char_start] : char_end)
+      self[:body][0].bind(
+        char_start,
+        consequent ? consequent[:char_start] : char_end
+      )
 
       # Next we're going to determine the rescue clause if there is one
       if parts[1]
         consequent = parts[2..-1].compact.first
-        self[:body][1].bind(consequent ? consequent[:char_start] : char_end)
+        self[:body][1].bind_end(consequent ? consequent[:char_start] : char_end)
       end
     end
   end
@@ -601,7 +618,16 @@ class Prettier::Parser < Ripper
   # accepts as an argument an args or args_add_block event that contains all
   # of the arguments being passed to the break.
   def on_break(args_add_block)
-    find_scanner_event(:@kw, 'break').merge!(
+    beging = find_scanner_event(:@kw, 'break')
+
+    # You can hit this if you are passing no arguments to break but it has a
+    # comment right after it. In that case we can just use the location
+    # information straight from the keyword.
+    if args_add_block[:type] == :args
+      return beging.merge!(type: :break, body: [args_add_block])
+    end
+
+    beging.merge!(
       type: :break,
       body: [args_add_block],
       end: args_add_block[:end],
@@ -621,6 +647,10 @@ class Prettier::Parser < Ripper
   #     foo.(1, 2, 3)
   #
   def on_call(receiver, oper, sending)
+    # Make sure we take the operator out of the scanner events so that it
+    # doesn't get confused for a unary operator later.
+    scanner_events.delete(oper)
+
     ending = sending
 
     if sending == :call
@@ -653,6 +683,27 @@ class Prettier::Parser < Ripper
     )
   end
 
+  # Finds the next position in the source string that begins a statement. This
+  # is used to bind statements lists and make sure they don't include a
+  # preceding comment. For example, we want the following comment to be attached
+  # to the class node and not the statement node:
+  #
+  #     class Foo # :nodoc:
+  #       ...
+  #     end
+  #
+  # By finding the next non-space character, we can make sure that the bounds of
+  # the statement list are correct.
+  def find_next_statement_start(position)
+    remaining = source[position..-1]
+
+    if remaining.sub(/\A +/, '')[0] == '#'
+      return position + remaining.index("\n")
+    end
+
+    position
+  end
+
   # class is a parser event that represents defining a class. It accepts as
   # arguments the name of the class, the optional name of the superclass,
   # and the bodystmt event that represents the statements evaluated within
@@ -661,7 +712,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'class')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind((superclass || const)[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start((superclass || const)[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :class,
@@ -761,6 +815,11 @@ class Prettier::Parser < Ripper
   #          └> ident
   #
   def on_def(ident, params, bodystmt)
+    # Make sure to delete this scanner event in case you're defining something
+    # like def class which would lead to this being a kw and causing all kinds
+    # of trouble
+    scanner_events.delete(ident)
+
     if params[:type] == :params && !params[:body].any?
       location = ident[:char_end]
       params.merge!(char_start: location, char_end: location)
@@ -769,7 +828,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'def')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(params[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start(params[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :def,
@@ -796,6 +858,11 @@ class Prettier::Parser < Ripper
   #          └> target
   #
   def on_defs(target, oper, ident, params, bodystmt)
+    # Make sure to delete this scanner event in case you're defining something
+    # like def class which would lead to this being a kw and causing all kinds
+    # of trouble
+    scanner_events.delete(ident)
+
     if params[:type] == :params && !params[:body].any?
       location = ident[:char_end]
       params.merge!(char_start: location, char_end: location)
@@ -804,7 +871,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'def')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(params[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start(params[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :defs,
@@ -998,7 +1068,10 @@ class Prettier::Parser < Ripper
   # event, so here we'll initialize the current embdoc.
   def on_embdoc_beg(value)
     @embdoc = {
-      type: :@embdoc, value: value, start: lineno, char_start: char_pos
+      type: :@embdoc,
+      value: value,
+      start: lineno,
+      char_start: char_pos
     }
   end
 
@@ -1029,13 +1102,23 @@ class Prettier::Parser < Ripper
   # and its subsequent statements.
   def on_ensure(stmts)
     beging = find_scanner_event(:@kw, 'ensure')
-    ending = find_scanner_event(:@kw, 'end')
 
-    stmts.bind(beging[:char_end], ending[:char_start])
+    # Specifically not using find_scanner_event here because we don't want to
+    # consume the :@end event, because that would break def..ensure..end chains.
+    index =
+      scanner_events.rindex do |scanner_event|
+        scanner_event[:type] == :@kw && scanner_event[:body] == 'end'
+      end
+
+    ending = scanner_events[index]
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :ensure,
-      body: [stmts],
+      body: [beging, stmts],
       start: beging[:start],
       char_start: beging[:char_start],
       end: ending[:end],
@@ -1105,7 +1188,8 @@ class Prettier::Parser < Ripper
       # Here we're going to expand out the location information for the assocs
       # node so that it can grab up any remaining comments inside the hash.
       assoclist_from_args.merge!(
-        char_start: beging[:char_end], char_end: ending[:char_start]
+        char_start: beging[:char_end],
+        char_end: ending[:char_start]
       )
     end
 
@@ -1126,21 +1210,28 @@ class Prettier::Parser < Ripper
   # prettier parser, we'll later attempt to print it using that parser and
   # printer through our embed function.
   def on_heredoc_beg(beging)
-    {
-      type: :heredoc,
-      beging: beging,
+    location = {
       start: lineno,
       end: lineno,
-      char_start: char_pos - beging.length + 1,
-      char_end: char_pos
-    }.tap { |node| @heredocs << node }
+      char_start: char_pos,
+      char_end: char_pos + beging.length + 1
+    }
+
+    # Here we're going to artificially create an extra node type so that if
+    # there are comments after the declaration of a heredoc, they get printed.
+    location
+      .merge(
+        type: :heredoc,
+        beging: location.merge(type: :@heredoc_beg, body: beging)
+      )
+      .tap { |node| @heredocs << node }
   end
 
   # This is a parser event that occurs when you're using a heredoc with a
   # tilde. These are considered `heredoc_dedent` nodes, whereas the hyphen
   # heredocs show up as string literals.
   def on_heredoc_dedent(string, _width)
-    @heredocs[-1].merge!(string.slice(:body))
+    @heredocs[-1].merge!(body: string[:body])
   end
 
   # This is a scanner event that represents the end of the heredoc.
@@ -1306,6 +1397,14 @@ class Prettier::Parser < Ripper
   # arguments and parentheses. It accepts as arguments the method being called
   # and the arg_paren event that contains the arguments to the method.
   def on_method_add_arg(fcall, arg_paren)
+    # You can hit this if you are passing no arguments to a method that ends in
+    # a question mark. Because it knows it has to be a method and not a local
+    # variable. In that case we can just use the location information straight
+    # from the fcall.
+    if arg_paren[:type] == :args
+      return fcall.merge(type: :method_add_arg, body: [fcall, arg_paren])
+    end
+
     {
       type: :method_add_arg,
       body: [fcall, arg_paren],
@@ -1352,7 +1451,9 @@ class Prettier::Parser < Ripper
       part.merge(type: :mlhs, body: [part])
     else
       mlhs.merge!(
-        body: mlhs[:body] << part, end: part[:end], char_end: part[:char_end]
+        body: mlhs[:body] << part,
+        end: part[:end],
+        char_end: part[:char_end]
       )
     end
   end
@@ -1418,7 +1519,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'module')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(const[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start(const[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :module,
@@ -1452,7 +1556,9 @@ class Prettier::Parser < Ripper
       part.merge(type: :mrhs, body: [part])
     else
       mrhs.merge!(
-        body: mrhs[:body] << part, end: part[:end], char_end: part[:char_end]
+        body: mrhs[:body] << part,
+        end: part[:end],
+        char_end: part[:char_end]
       )
     end
   end
@@ -1553,7 +1659,10 @@ class Prettier::Parser < Ripper
   # some found at the end of the source string.
   def on_program(stmts)
     range = {
-      start: 1, end: lines.length, char_start: 0, char_end: source.length
+      start: 1,
+      end: lines.length,
+      char_start: 0,
+      char_end: source.length
     }
 
     stmts[:body] << @__end__ if @__end__
@@ -1610,7 +1719,8 @@ class Prettier::Parser < Ripper
   # expression literal, like /foo/. It can be followed by any number of
   # regexp_add events, which we'll append onto an array body.
   def on_regexp_new
-    find_scanner_event(:@regexp_beg).merge!(type: :regexp, body: [])
+    beging = find_scanner_event(:@regexp_beg)
+    beging.merge!(type: :regexp, body: [], beging: beging[:body])
   end
 
   # regexp_add is a parser event that represents a piece of a regular
@@ -1643,17 +1753,17 @@ class Prettier::Parser < Ripper
   # determine its ending. Therefore it relies on its parent bodystmt node to
   # report its ending to it.
   class Rescue < SimpleDelegator
-    def bind(char_end)
+    def bind_end(char_end)
       merge!(char_end: char_end)
 
       stmts = self[:body][2]
       consequent = self[:body][3]
 
       if consequent
-        consequent.bind(char_end)
-        stmts.bind(stmts[:char_start], consequent[:char_start])
+        consequent.bind_end(char_end)
+        stmts.bind_end(consequent[:char_start])
       else
-        stmts.bind(stmts[:char_start], char_end)
+        stmts.bind_end(char_end)
       end
     end
   end
@@ -1663,10 +1773,10 @@ class Prettier::Parser < Ripper
   def on_rescue(exceptions, variable, stmts, consequent)
     beging = find_scanner_event(:@kw, 'rescue')
 
-    stmts.bind(
-      ((exceptions || [])[-1] || variable || beging)[:char_end],
-      char_pos
-    )
+    last_exception = exceptions.is_a?(Array) ? exceptions[-1] : exceptions
+    last_node = variable || last_exception || beging
+
+    stmts.bind(find_next_statement_start(last_node[:char_end]), char_pos)
 
     Rescue.new(
       beging.merge!(
@@ -1750,7 +1860,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'class')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(target[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start(target[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :sclass,
@@ -1778,6 +1891,10 @@ class Prettier::Parser < Ripper
       end
     end
 
+    def bind_end(char_end)
+      merge!(char_end: char_end)
+    end
+
     def <<(statement)
       if self[:body].any?
         merge!(statement.slice(:end, :char_end))
@@ -1851,7 +1968,9 @@ class Prettier::Parser < Ripper
   # piece of the string.
   def on_string_add(string, piece)
     string.merge!(
-      body: string[:body] << piece, end: piece[:end], char_end: piece[:char_end]
+      body: string[:body] << piece,
+      end: piece[:end],
+      char_end: piece[:char_end]
     )
   end
 
@@ -1948,7 +2067,7 @@ class Prettier::Parser < Ripper
   # symbol node (for most cases) or an ident node (in the case that we're
   # using bare words, as in an alias node like alias foo bar).
   def on_symbol_literal(contents)
-    if contents[:type] == :@ident
+    if scanner_events[-1] == contents
       contents.merge(type: :symbol_literal, body: [contents])
     else
       beging = find_scanner_event(:@symbeg)
@@ -2042,7 +2161,18 @@ class Prettier::Parser < Ripper
         paren: paren
       )
     else
-      find_scanner_event(:@op).merge!(
+      # Special case instead of using find_scanner_event here. It turns out that
+      # if you have a range that goes from a negative number to a negative
+      # number then you can end up with a .. or a ... that's higher in the
+      # stack. So we need to explicitly disallow those operators.
+      index =
+        scanner_events.rindex do |scanner_event|
+          scanner_event[:type] == :@op &&
+            !%w[.. ...].include?(scanner_event[:body])
+        end
+
+      beging = scanner_events.delete_at(index)
+      beging.merge!(
         type: :unary,
         oper: oper[0],
         body: [value],
@@ -2297,7 +2427,9 @@ class Prettier::Parser < Ripper
       piece.merge(type: :word, body: [piece])
     else
       word.merge!(
-        body: word[:body] << piece, end: piece[:end], char_end: piece[:char_end]
+        body: word[:body] << piece,
+        end: piece[:end],
+        char_end: piece[:char_end]
       )
     end
   end
@@ -2335,6 +2467,8 @@ class Prettier::Parser < Ripper
 
     if heredoc && heredoc[:beging][3] = '`'
       heredoc.merge(type: :xstring, body: [])
+    elsif RUBY_MAJOR <= 2 && RUBY_MINOR <= 5 && RUBY_PATCH < 7
+      { type: :xstring, body: [] }
     else
       find_scanner_event(:@backtick).merge!(type: :xstring, body: [])
     end
@@ -2376,7 +2510,9 @@ class Prettier::Parser < Ripper
     else
       ending = find_scanner_event(:@tstring_end)
       xstring.merge!(
-        type: :xstring_literal, end: ending[:end], char_end: ending[:char_end]
+        type: :xstring_literal,
+        end: ending[:end],
+        char_end: ending[:char_end]
       )
     end
   end