prettier 1.2.0 → 1.2.5

data/src/{nodes → ruby/nodes}/regexp.js

@@ -1,5 +1,5 @@
-const { concat } = require("../prettier");
-const { hasAncestor } = require("../utils");
+const { concat } = require("../../prettier");
+const { hasAncestor } = require("../../utils");
 
 function hasContent(node, pattern) {
   return node.body.some(

data/src/{nodes → ruby/nodes}/rescue.js

@@ -6,8 +6,8 @@ const {
   indent,
   join,
   line
-} = require("../prettier");
-const { literal } = require("../utils");
+} = require("../../prettier");
+const { literal } = require("../../utils");
 
 function printBegin(path, opts, print) {
   return concat([

data/src/ruby/nodes/return.js

@@ -0,0 +1,94 @@
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  line,
+  join,
+  softline
+} = require("../../prettier");
+const { literal } = require("../../utils");
+
+// You can't skip the parentheses if you have comments or certain operators with
+// lower precedence than the return keyword.
+const canSkipParens = (args) => {
+  const stmts = args.body[0].body[0];
+
+  // return(
+  //   # a
+  //   b
+  // )
+  if (stmts.comments) {
+    return false;
+  }
+
+  const stmt = stmts.body[0];
+
+  // return (a or b)
+  if (stmt.type === "binary" && ["and", "or"].includes(stmt.body[1])) {
+    return false;
+  }
+
+  // return (not a)
+  if (stmt.type === "unary" && stmt.oper === "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);
+    }
+  }
+
+  // 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.apply(path, [print].concat(steps));
+
+  // 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(concat([",", 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 concat(["return", value]);
+  }
+
+  return group(
+    concat([
+      "return",
+      ifBreak(parts.length > 1 ? " [" : "(", " "),
+      indent(concat([softline, value])),
+      concat([softline, ifBreak(parts.length > 1 ? "]" : ")", "")])
+    ])
+  );
+};
+
+module.exports = {
+  return: printReturn,
+  return0: literal("return")
+};

data/src/{nodes → ruby/nodes}/statements.js

@@ -10,7 +10,7 @@ const {
   literalline,
   softline,
   trim
-} = require("../prettier");
+} = require("../../prettier");
 
 function printBodyStmt(path, opts, print) {
   const [stmts, rescue, elseClause, ensure] = path.getValue().body;
@@ -30,6 +30,7 @@ function printBodyStmt(path, opts, print) {
 
   if (elseClause) {
     // 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)
@@ -69,11 +70,7 @@ function printParen(path, opts, print) {
   }
 
   return group(
-    concat([
-      "(",
-      indent(concat([softline, contentDoc])),
-      concat([softline, ")"])
-    ])
+    concat(["(", indent(concat([softline, contentDoc])), softline, ")"])
   );
 }
 
@@ -123,12 +120,12 @@ module.exports = {
       if (lineNo === null) {
         parts.push(printed);
       } else if (
-        stmt.start - lineNo > 1 ||
+        stmt.sl - lineNo > 1 ||
         [stmt.type, stmts[index - 1].type].includes("access_ctrl")
       ) {
         parts.push(hardline, hardline, printed);
       } else if (
-        stmt.start !== lineNo ||
+        stmt.sl !== lineNo ||
         path.getParentNode().type !== "string_embexpr"
       ) {
         parts.push(hardline, printed);
@@ -136,7 +133,7 @@ module.exports = {
         parts.push("; ", printed);
       }
 
-      lineNo = stmt.end;
+      lineNo = stmt.el;
     });
 
     return concat(parts);

data/src/{nodes → ruby/nodes}/strings.js

@@ -6,7 +6,7 @@ const {
   literalline,
   softline,
   join
-} = require("../prettier");
+} = require("../../prettier");
 
 // If there is some part of this string that matches an escape sequence or that
 // contains the interpolation pattern ("#{"), then we are locked into whichever
@@ -31,17 +31,10 @@ function isSingleQuotable(node) {
 
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
 
-function normalizeQuotes(content, enclosingQuote, originalQuote) {
-  const replaceOther = originalQuote === '"';
-  const otherQuote = enclosingQuote === '"' ? "'" : '"';
-
+function normalizeQuotes(content, enclosingQuote) {
   // Escape and unescape single and double quotes as needed to be able to
   // enclose `content` with `enclosingQuote`.
   return content.replace(quotePattern, (match, escaped, quote) => {
-    if (replaceOther && escaped === otherQuote) {
-      return escaped;
-    }
-
     if (quote === enclosingQuote) {
       return `\\${quote}`;
     }
@@ -97,12 +90,34 @@ function printDynaSymbol(path, opts, print) {
   return concat([":", quote].concat(path.map(print, "body")).concat(quote));
 }
 
+function printStringConcat(path, opts, print) {
+  const [leftDoc, rightDoc] = path.map(print, "body");
+
+  return group(concat([leftDoc, " \\", indent(concat([hardline, rightDoc]))]));
+}
+
 // Prints out an interpolated variable in the string by converting it into an
 // embedded expression.
 function printStringDVar(path, opts, print) {
   return concat(["#{", path.call(print, "body", 0), "}"]);
 }
 
+function printStringEmbExpr(path, opts, print) {
+  const parts = path.call(print, "body", 0);
+
+  // 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, "}"]);
+  }
+
+  return group(
+    concat(["#{", indent(concat([softline, parts])), concat([softline, "}"])])
+  );
+}
+
 // Prints out a literal string. This function does its best to respect the
 // 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
@@ -131,10 +146,7 @@ function printStringLiteral(path, { rubySingleQuote }, print) {
     }
 
     // In this case, the part of the string is just regular string content
-    return join(
-      literalline,
-      normalizeQuotes(part.body, quote, node.quote).split("\n")
-    );
+    return join(literalline, normalizeQuotes(part.body, quote).split("\n"));
   });
 
   return concat([quote].concat(parts).concat(getClosingQuote(quote)));
@@ -155,30 +167,9 @@ function printXStringLiteral(path, opts, print) {
 module.exports = {
   "@CHAR": printChar,
   dyna_symbol: printDynaSymbol,
-  string_concat: (path, opts, print) =>
-    group(
-      concat([
-        path.call(print, "body", 0),
-        " \\",
-        indent(concat([hardline, path.call(print, "body", 1)]))
-      ])
-    ),
+  string_concat: printStringConcat,
   string_dvar: printStringDVar,
-  string_embexpr: (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
-
-    // 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, "}"]);
-    }
-
-    return group(
-      concat(["#{", indent(concat([softline, parts])), concat([softline, "}"])])
-    );
-  },
+  string_embexpr: printStringEmbExpr,
   string_literal: printStringLiteral,
   symbol_literal: printSymbolLiteral,
   xstring_literal: printXStringLiteral

data/src/{nodes → ruby/nodes}/super.js

@@ -1,5 +1,5 @@
-const { align, concat, group, join, line } = require("../prettier");
-const { literal } = require("../utils");
+const { align, concat, group, join, line } = require("../../prettier");
+const { literal } = require("../../utils");
 
 function printSuper(path, opts, print) {
   const args = path.getValue().body[0];

data/src/{nodes → ruby/nodes}/undef.js

@@ -5,7 +5,7 @@ const {
   group,
   join,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 function printUndefSymbol(path, opts, print) {
   const node = path.getValue();

data/src/{parser.js → ruby/parser.js}

@@ -4,6 +4,7 @@ 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.
+/* istanbul ignore next */
 const LANG = (() => {
   const { env, platform } = process;
   const envValue = env.LC_ALL || env.LC_CTYPE || env.LANG;
@@ -42,7 +43,7 @@ function parse(text, _parsers, _opts) {
     {
       env: Object.assign({}, process.env, { LANG }),
       input: text,
-      maxBuffer: 10 * 1024 * 1024 // 10MB
+      maxBuffer: 15 * 1024 * 1024 // 15MB
     }
   );
 
@@ -67,14 +68,14 @@ function hasPragma(text) {
 // for returning the index of the character within the source string that is the
 // beginning of the given node.
 function locStart(node) {
-  return node.char_start;
+  return node.sc;
 }
 
 // This function is critical for comments and cursor support, and is responsible
 // for returning the index of the character within the source string that is the
 // ending of the given node.
 function locEnd(node) {
-  return node.char_end;
+  return node.ec;
 }
 
 module.exports = {

data/src/{parser.rb → ruby/parser.rb}

@@ -63,14 +63,14 @@ class Prettier::Parser < Ripper
   # would happen to be the innermost keyword). Then the outer one would only be
   # able to grab the first one. In this way all of the scanner events act as
   # their own stack.
-  def find_scanner_event(type, body = :any)
+  def find_scanner_event(type, body = :any, consume: true)
     index =
       scanner_events.rindex do |scanner_event|
         scanner_event[:type] == type &&
           (body == :any || (scanner_event[:body] == body))
       end
 
-    scanner_events.delete_at(index)
+    consume ? scanner_events.delete_at(index) : (index && scanner_events[index])
   end
 
   # Scanner events occur when the lexer hits a new token, like a keyword or an
@@ -89,14 +89,14 @@ class Prettier::Parser < Ripper
 
   (SCANNER_EVENTS - defined).each do |event|
     define_method(:"on_#{event}") do |value|
-      char_end = char_pos + value.size
+      ec = char_pos + value.size
       node = {
         type: :"@#{event}",
         body: value,
-        start: lineno,
-        end: lineno,
-        char_start: char_pos,
-        char_end: char_end
+        sl: lineno,
+        el: lineno,
+        sc: char_pos,
+        ec: ec
       }
 
       scanner_events << node
@@ -118,10 +118,10 @@ class Prettier::Parser < Ripper
     @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
+      sl: lineno,
+      el: lineno,
+      sc: char_pos,
+      ec: char_pos + value.length - 1
     }
   end
 
@@ -138,10 +138,10 @@ class Prettier::Parser < Ripper
     {
       type: :ignored_nl,
       body: nil,
-      start: lineno,
-      end: lineno,
-      char_start: char_pos,
-      char_end: char_pos
+      sl: lineno,
+      el: lineno,
+      sc: char_pos,
+      ec: char_pos
     }
   end
 
@@ -186,16 +186,13 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@lbrace)
     ending = find_scanner_event(:@rbrace)
 
-    stmts.bind(
-      find_next_statement_start(beging[:char_end]),
-      ending[:char_start]
-    )
+    stmts.bind(find_next_statement_start(beging[:ec]), ending[:sc])
 
     find_scanner_event(:@kw, 'BEGIN').merge!(
       type: :BEGIN,
       body: [beging, stmts],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      el: ending[:el],
+      ec: ending[:ec]
     )
   end
 
@@ -213,16 +210,13 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@lbrace)
     ending = find_scanner_event(:@rbrace)
 
-    stmts.bind(
-      find_next_statement_start(beging[:char_end]),
-      ending[:char_start]
-    )
+    stmts.bind(find_next_statement_start(beging[:ec]), ending[:sc])
 
     find_scanner_event(:@kw, 'END').merge!(
       type: :END,
       body: [beging, stmts],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      el: ending[:el],
+      ec: ending[:ec]
     )
   end
 
@@ -234,16 +228,16 @@ class Prettier::Parser < Ripper
   def on_alias(left, right)
     beging = find_scanner_event(:@kw, 'alias')
 
-    paren = source[beging[:char_end]...left[:char_start]].include?('(')
+    paren = source[beging[:ec]...left[:sc]].include?('(')
     ending = paren ? find_scanner_event(:@rparen) : right
 
     {
       type: :alias,
       body: [left, right],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -268,10 +262,10 @@ class Prettier::Parser < Ripper
     {
       type: :aref,
       body: [collection, index],
-      start: collection[:start],
-      char_start: collection[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: collection[:sl],
+      sc: collection[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -284,10 +278,10 @@ class Prettier::Parser < Ripper
     {
       type: :aref_field,
       body: [collection, index],
-      start: collection[:start],
-      char_start: collection[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: collection[:sl],
+      sc: collection[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -298,10 +292,10 @@ class Prettier::Parser < Ripper
     {
       type: :args,
       body: [],
-      start: lineno,
-      char_start: char_pos,
-      end: lineno,
-      char_end: char_pos
+      sl: lineno,
+      sc: char_pos,
+      el: lineno,
+      ec: char_pos
     }
   end
 
@@ -313,11 +307,7 @@ class Prettier::Parser < Ripper
     if args[:body].empty?
       arg.merge(type: :args, body: [arg])
     else
-      args.merge!(
-        body: args[:body] << arg,
-        end: arg[:end],
-        char_end: arg[:char_end]
-      )
+      args.merge!(body: args[:body] << arg, el: arg[:el], ec: arg[:ec])
     end
   end
 
@@ -330,8 +320,8 @@ class Prettier::Parser < Ripper
     args.merge(
       type: :args_add_block,
       body: [args, block],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      el: ending[:el],
+      ec: ending[:ec]
     )
   end
 
@@ -345,10 +335,10 @@ class Prettier::Parser < Ripper
     {
       type: :args_add_star,
       body: [args, part],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -367,15 +357,15 @@ class Prettier::Parser < Ripper
     # 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
+    ending = (args && args[:el] > rparen[:el]) ? args : rparen
 
     {
       type: :arg_paren,
       body: [args],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -391,20 +381,20 @@ class Prettier::Parser < Ripper
       {
         type: :array,
         body: [contents],
-        start: beging[:start],
-        char_start: beging[:char_start],
-        end: ending[:end],
-        char_end: ending[:char_end]
+        sl: beging[:sl],
+        sc: beging[:sc],
+        el: ending[:el],
+        ec: ending[:ec]
       }
     else
       ending = find_scanner_event(:@tstring_end)
-      contents[:char_end] = ending[:char_end]
+      contents[:ec] = ending[:ec]
 
       ending.merge!(
         type: :array,
         body: [contents],
-        start: contents[:start],
-        char_start: contents[:char_start]
+        sl: contents[:sl],
+        sc: contents[:sc]
       )
     end
   end
@@ -417,10 +407,10 @@ class Prettier::Parser < Ripper
     {
       type: :aryptn,
       body: [const, preargs, splatarg, postargs],
-      start: pieces[0][:start],
-      char_start: pieces[0][:char_start],
-      end: pieces[-1][:end],
-      char_end: pieces[-1][:char_end]
+      sl: pieces[0][:sl],
+      sc: pieces[0][:sc],
+      el: pieces[-1][:el],
+      ec: pieces[-1][:ec]
     }
   end
 
@@ -431,8 +421,8 @@ class Prettier::Parser < Ripper
     left.merge(
       type: :assign,
       body: [left, right],
-      end: right[:end],
-      char_end: right[:char_end]
+      el: right[:el],
+      ec: right[:ec]
     )
   end
 
@@ -443,10 +433,10 @@ class Prettier::Parser < Ripper
     {
       type: :assoc_new,
       body: [key, value],
-      start: key[:start],
-      char_start: key[:char_start],
-      end: value[:end],
-      char_end: value[:char_end]
+      sl: key[:sl],
+      sc: key[:sc],
+      el: value[:el],
+      ec: value[:ec]
     }
   end
 
@@ -456,8 +446,8 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@op, '**').merge!(
       type: :assoc_splat,
       body: [contents],
-      end: contents[:end],
-      char_end: contents[:char_end]
+      el: contents[:el],
+      ec: contents[:ec]
     )
   end
 
@@ -469,10 +459,10 @@ class Prettier::Parser < Ripper
     {
       type: :assoclist_from_args,
       body: assocs,
-      start: assocs[0][:start],
-      char_start: assocs[0][:char_start],
-      end: assocs[-1][:end],
-      char_end: assocs[-1][:char_end]
+      sl: assocs[0][:sl],
+      sc: assocs[0][:sc],
+      el: assocs[-1][:el],
+      ec: assocs[-1][:ec]
     }
   end
 
@@ -484,10 +474,10 @@ class Prettier::Parser < Ripper
     {
       type: :bare_assoc_hash,
       body: assoc_news,
-      start: assoc_news[0][:start],
-      char_start: assoc_news[0][:char_start],
-      end: assoc_news[-1][:end],
-      char_end: assoc_news[-1][:char_end]
+      sl: assoc_news[0][:sl],
+      sc: assoc_news[0][:sc],
+      el: assoc_news[-1][:el],
+      ec: assoc_news[-1][:ec]
     }
   end
 
@@ -495,20 +485,20 @@ class Prettier::Parser < Ripper
   # It includes a bodystmt event that has all of the consequent clauses.
   def on_begin(bodystmt)
     beging = find_scanner_event(:@kw, 'begin')
-    char_end =
+    ec =
       if bodystmt[:body][1..-1].any?
-        bodystmt[:char_end]
+        bodystmt[:ec]
       else
-        find_scanner_event(:@kw, 'end')[:char_end]
+        find_scanner_event(:@kw, 'end')[:ec]
       end
 
-    bodystmt.bind(beging[:char_end], char_end)
+    bodystmt.bind(beging[:ec], ec)
 
     beging.merge!(
       type: :begin,
       body: [bodystmt],
-      end: bodystmt[:end],
-      char_end: bodystmt[:char_end]
+      el: bodystmt[:el],
+      ec: bodystmt[:ec]
     )
   end
 
@@ -518,10 +508,10 @@ class Prettier::Parser < Ripper
     {
       type: :binary,
       body: [left, oper, right],
-      start: left[:start],
-      char_start: left[:char_start],
-      end: right[:end],
-      char_end: right[:char_end]
+      sl: left[:sl],
+      sc: left[:sc],
+      el: right[:el],
+      ec: right[:ec]
     }
   end
 
@@ -531,7 +521,7 @@ class Prettier::Parser < Ripper
     index =
       scanner_events.rindex do |event|
         event[:type] == :@op && %w[| ||].include?(event[:body]) &&
-          event[:char_start] < params[:char_start]
+          event[:sc] < params[:sc]
       end
 
     beging = scanner_events[index]
@@ -540,10 +530,10 @@ class Prettier::Parser < Ripper
     {
       type: :block_var,
       body: [params, locals],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -553,8 +543,8 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@op, '&').merge!(
       type: :blockarg,
       body: [ident],
-      end: ident[:end],
-      char_end: ident[:char_end]
+      el: ident[:el],
+      ec: ident[:ec]
     )
   end
 
@@ -562,21 +552,18 @@ class Prettier::Parser < Ripper
   # doesn't necessarily know where it started. So the parent node needs to
   # report back down into this one where it goes.
   class BodyStmt < SimpleDelegator
-    def bind(char_start, char_end)
-      merge!(char_start: char_start, char_end: char_end)
+    def bind(sc, ec)
+      merge!(sc: sc, ec: ec)
       parts = self[:body]
 
       # 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(sc, consequent ? consequent[:sc] : ec)
 
       # 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_end(consequent ? consequent[:char_start] : char_end)
+        self[:body][1].bind_end(consequent ? consequent[:sc] : ec)
       end
     end
   end
@@ -587,10 +574,10 @@ class Prettier::Parser < Ripper
     BodyStmt.new(
       type: :bodystmt,
       body: [stmts, rescued, ensured, elsed],
-      start: lineno,
-      char_start: char_pos,
-      end: lineno,
-      char_end: char_pos
+      sl: lineno,
+      sc: char_pos,
+      el: lineno,
+      ec: char_pos
     )
   end
 
@@ -602,15 +589,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@lbrace)
     ending = find_scanner_event(:@rbrace)
 
-    stmts.bind((block_var || beging)[:char_end], ending[:char_start])
+    stmts.bind((block_var || beging)[:ec], ending[:sc])
 
     {
       type: :brace_block,
       body: [block_var, stmts],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -630,8 +617,8 @@ class Prettier::Parser < Ripper
     beging.merge!(
       type: :break,
       body: [args_add_block],
-      end: args_add_block[:end],
-      char_end: args_add_block[:char_end]
+      el: args_add_block[:el],
+      ec: args_add_block[:ec]
     )
   end
 
@@ -647,10 +634,6 @@ 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
@@ -664,10 +647,10 @@ class Prettier::Parser < Ripper
     {
       type: :call,
       body: [receiver, oper, sending],
-      start: receiver[:start],
-      char_start: receiver[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: receiver[:sl],
+      sc: receiver[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -675,11 +658,18 @@ class Prettier::Parser < Ripper
   # It accepts as arguments the switch of the case and the consequent
   # clause.
   def on_case(switch, consequent)
-    find_scanner_event(:@kw, 'case').merge!(
-      type: :case,
+    beging =
+      if event = find_scanner_event(:@kw, 'case', consume: false)
+        scanner_events.delete(event).merge!(type: :case)
+      else
+        keyword = find_scanner_event(:@kw, 'in', consume: false)
+        switch.merge(type: :rassign, keyword: keyword)
+      end
+
+    beging.merge!(
       body: [switch, consequent],
-      end: consequent[:end],
-      char_end: consequent[:char_end]
+      el: consequent[:el],
+      ec: consequent[:ec]
     )
   end
 
@@ -713,17 +703,17 @@ class Prettier::Parser < Ripper
     ending = find_scanner_event(:@kw, 'end')
 
     bodystmt.bind(
-      find_next_statement_start((superclass || const)[:char_end]),
-      ending[:char_start]
+      find_next_statement_start((superclass || const)[:ec]),
+      ending[:sc]
     )
 
     {
       type: :class,
       body: [const, superclass, bodystmt],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -734,10 +724,10 @@ class Prettier::Parser < Ripper
     {
       type: :command,
       body: [ident, args],
-      start: ident[:start],
-      char_start: ident[:char_start],
-      end: args[:end],
-      char_end: args[:char_end]
+      sl: ident[:sl],
+      sc: ident[:sc],
+      el: args[:el],
+      ec: args[:ec]
     }
   end
 
@@ -751,10 +741,10 @@ class Prettier::Parser < Ripper
     {
       type: :command_call,
       body: [receiver, oper, ident, args],
-      start: receiver[:start],
-      char_start: receiver[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: receiver[:sl],
+      sc: receiver[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -768,10 +758,10 @@ class Prettier::Parser < Ripper
     {
       type: :const_path_field,
       body: [left, const],
-      start: left[:start],
-      char_start: left[:char_start],
-      end: const[:end],
-      char_end: const[:char_end]
+      sl: left[:sl],
+      sc: left[:sc],
+      el: const[:el],
+      ec: const[:ec]
     }
   end
 
@@ -785,10 +775,10 @@ class Prettier::Parser < Ripper
     {
       type: :const_path_ref,
       body: [left, const],
-      start: left[:start],
-      char_start: left[:char_start],
-      end: const[:end],
-      char_end: const[:char_end]
+      sl: left[:sl],
+      sc: left[:sc],
+      el: const[:el],
+      ec: const[:ec]
     }
   end
 
@@ -832,39 +822,36 @@ class Prettier::Parser < Ripper
     # and normal method definitions.
     beging = find_scanner_event(:@kw, 'def')
 
-    # If there is not a params node, then we have a single-line method
-    unless params
+    # If we don't have a bodystmt node, then we have a single-line method
+    if bodystmt[:type] != :bodystmt
       return(
         {
           type: :defsl,
-          body: [ident, bodystmt],
-          start: beging[:start],
-          char_start: beging[:char_start],
-          end: bodystmt[:end],
-          char_end: bodystmt[:char_end]
+          body: [ident, params, bodystmt],
+          sl: beging[:sl],
+          sc: beging[:sc],
+          el: bodystmt[:el],
+          ec: bodystmt[:ec]
         }
       )
     end
 
     if params[:type] == :params && !params[:body].any?
-      location = ident[:char_end]
-      params.merge!(char_start: location, char_end: location)
+      location = ident[:ec]
+      params.merge!(sc: location, ec: location)
     end
 
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(
-      find_next_statement_start(params[:char_end]),
-      ending[:char_start]
-    )
+    bodystmt.bind(find_next_statement_start(params[:ec]), ending[:sc])
 
     {
       type: :def,
       body: [ident, params, bodystmt],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -889,25 +876,22 @@ class Prettier::Parser < Ripper
     scanner_events.delete(ident)
 
     if params[:type] == :params && !params[:body].any?
-      location = ident[:char_end]
-      params.merge!(char_start: location, char_end: location)
+      location = ident[:ec]
+      params.merge!(sc: location, ec: location)
     end
 
     beging = find_scanner_event(:@kw, 'def')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(
-      find_next_statement_start(params[:char_end]),
-      ending[:char_start]
-    )
+    bodystmt.bind(find_next_statement_start(params[:ec]), ending[:sc])
 
     {
       type: :defs,
       body: [target, oper, ident, params, bodystmt],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -918,14 +902,14 @@ class Prettier::Parser < Ripper
   def on_defined(value)
     beging = find_scanner_event(:@kw, 'defined?')
 
-    paren = source[beging[:char_end]...value[:char_start]].include?('(')
+    paren = source[beging[:ec]...value[:sc]].include?('(')
     ending = paren ? find_scanner_event(:@rparen) : value
 
     beging.merge!(
       type: :defined,
       body: [value],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      el: ending[:el],
+      ec: ending[:ec]
     )
   end
 
@@ -937,15 +921,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'do')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind((block_var || beging)[:char_end], ending[:char_start])
+    bodystmt.bind((block_var || beging)[:ec], ending[:sc])
 
     {
       type: :do_block,
       body: [block_var, bodystmt],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -961,10 +945,10 @@ class Prettier::Parser < Ripper
     {
       type: :dot2,
       body: [left, right],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -980,10 +964,10 @@ class Prettier::Parser < Ripper
     {
       type: :dot3,
       body: [left, right],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1006,7 +990,7 @@ class Prettier::Parser < Ripper
   #
   # which would be the same symbol as above.
   def on_dyna_symbol(string)
-    if scanner_events.any? { |event| event[:type] == :@symbeg }
+    if find_scanner_event(:@symbeg, consume: false)
       # A normal dynamic symbol
       beging = find_scanner_event(:@symbeg)
       ending = find_scanner_event(:@tstring_end)
@@ -1015,8 +999,8 @@ class Prettier::Parser < Ripper
         type: :dyna_symbol,
         quote: beging[:body][1],
         body: string[:body],
-        end: ending[:end],
-        char_end: ending[:char_end]
+        el: ending[:el],
+        ec: ending[:ec]
       )
     else
       # A dynamic symbol as a hash key
@@ -1026,10 +1010,10 @@ class Prettier::Parser < Ripper
       string.merge!(
         type: :dyna_symbol,
         quote: ending[:body][0],
-        start: beging[:start],
-        char_start: beging[:char_start],
-        end: ending[:end],
-        char_end: ending[:char_end]
+        sl: beging[:sl],
+        sc: beging[:sc],
+        el: ending[:el],
+        ec: ending[:ec]
       )
     end
   end
@@ -1054,15 +1038,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'else')
     ending = find_else_ending
 
-    stmts.bind(beging[:char_end], ending[:char_start])
+    stmts.bind(beging[:ec], ending[:sc])
 
     {
       type: :else,
       body: [stmts],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1074,15 +1058,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'elsif')
     ending = consequent || find_scanner_event(:@kw, 'end')
 
-    stmts.bind(predicate[:char_end], ending[:char_start])
+    stmts.bind(predicate[:ec], ending[:sc])
 
     {
       type: :elsif,
       body: [predicate, stmts, consequent],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1092,12 +1076,7 @@ class Prettier::Parser < Ripper
   # and add to it as we get content. It always starts with this scanner
   # 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
-    }
+    @embdoc = { type: :@embdoc, value: value, sl: lineno, sc: char_pos }
   end
 
   # This is a scanner event that gets hit when we're inside an embdoc and
@@ -1116,8 +1095,8 @@ class Prettier::Parser < Ripper
     @comments <<
       @embdoc.merge!(
         value: @embdoc[:value] << value.chomp,
-        end: lineno,
-        char_end: char_pos + value.length - 1
+        el: lineno,
+        ec: char_pos + value.length - 1
       )
 
     @embdoc = nil
@@ -1136,18 +1115,15 @@ class Prettier::Parser < Ripper
       end
 
     ending = scanner_events[index]
-    stmts.bind(
-      find_next_statement_start(beging[:char_end]),
-      ending[:char_start]
-    )
+    stmts.bind(find_next_statement_start(beging[:ec]), ending[:sc])
 
     {
       type: :ensure,
       body: [beging, stmts],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1175,10 +1151,10 @@ class Prettier::Parser < Ripper
     {
       type: :field,
       body: [left, oper, right],
-      start: left[:start],
-      char_start: left[:char_start],
-      end: right[:end],
-      char_end: right[:char_end]
+      sl: left[:sl],
+      sc: left[:sc],
+      el: right[:el],
+      ec: right[:ec]
     }
   end
 
@@ -1188,15 +1164,13 @@ class Prettier::Parser < Ripper
     beging = const || find_scanner_event(:@lbracket)
     ending = find_scanner_event(:@rbracket)
 
-    pieces = [const, presplat, *args, postsplat].compact
-
     {
       type: :fndptn,
       body: [const, presplat, args, postsplat],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1208,15 +1182,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'for')
     ending = find_scanner_event(:@kw, 'end')
 
-    stmts.bind(enumerable[:char_end], ending[:char_start])
+    stmts.bind(enumerable[:ec], ending[:sc])
 
     {
       type: :for,
       body: [ident, enumerable, stmts],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1230,19 +1204,16 @@ class Prettier::Parser < Ripper
     if assoclist_from_args
       # 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]
-      )
+      assoclist_from_args.merge!(sc: beging[:ec], ec: ending[:sc])
     end
 
     {
       type: :hash,
       body: [assoclist_from_args],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1254,10 +1225,10 @@ class Prettier::Parser < Ripper
   # printer through our embed function.
   def on_heredoc_beg(beging)
     location = {
-      start: lineno,
-      end: lineno,
-      char_start: char_pos,
-      char_end: char_pos + beging.length + 1
+      sl: lineno,
+      el: lineno,
+      sc: char_pos,
+      ec: char_pos + beging.length + 1
     }
 
     # Here we're going to artificially create an extra node type so that if
@@ -1279,7 +1250,7 @@ class Prettier::Parser < Ripper
 
   # This is a scanner event that represents the end of the heredoc.
   def on_heredoc_end(ending)
-    @heredocs[-1].merge!(ending: ending.chomp, end: lineno, char_end: char_pos)
+    @heredocs[-1].merge!(ending: ending.chomp, el: lineno, ec: char_pos)
   end
 
   # hshptn is a parser event that represents matching against a hash pattern
@@ -1290,10 +1261,10 @@ class Prettier::Parser < Ripper
     {
       type: :hshptn,
       body: [const, kw, kwrest],
-      start: pieces[0][:start],
-      char_start: pieces[0][:char_start],
-      end: pieces[-1][:end],
-      char_end: pieces[-1][:char_end]
+      sl: pieces[0][:sl],
+      sc: pieces[0][:sc],
+      el: pieces[-1][:el],
+      ec: pieces[-1][:ec]
     }
   end
 
@@ -1304,15 +1275,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'if')
     ending = consequent || find_scanner_event(:@kw, 'end')
 
-    stmts.bind(predicate[:char_end], ending[:char_start])
+    stmts.bind(predicate[:ec], ending[:sc])
 
     {
       type: :if,
       body: [predicate, stmts, consequent],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1323,8 +1294,8 @@ class Prettier::Parser < Ripper
     predicate.merge(
       type: :ifop,
       body: [predicate, truthy, falsy],
-      end: falsy[:end],
-      char_end: falsy[:char_end]
+      el: falsy[:el],
+      ec: falsy[:ec]
     )
   end
 
@@ -1337,26 +1308,30 @@ class Prettier::Parser < Ripper
     {
       type: :if_mod,
       body: [predicate, statement],
-      start: statement[:start],
-      char_start: statement[:char_start],
-      end: predicate[:end],
-      char_end: predicate[:char_end]
+      sl: statement[:sl],
+      sc: statement[:sc],
+      el: predicate[:el],
+      ec: predicate[:ec]
     }
   end
 
   # in is a parser event that represents using the in keyword within the
-  # Ruby 2.7+ pattern matching syntax.
+  # Ruby 2.7+ pattern matching syntax. Alternatively in Ruby 3+ it is also used
+  # to handle rightward assignment for pattern matching.
   def on_in(pattern, stmts, consequent)
+    # Here we have a rightward assignment
+    return pattern unless stmts
+
     beging = find_scanner_event(:@kw, 'in')
     ending = consequent || find_scanner_event(:@kw, 'end')
 
-    stmts.bind(beging[:char_end], ending[:char_start])
+    stmts.bind(beging[:ec], ending[:sc])
 
     beging.merge!(
       type: :in,
       body: [pattern, stmts, consequent],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      el: ending[:el],
+      ec: ending[:ec]
     )
   end
 
@@ -1369,8 +1344,8 @@ class Prettier::Parser < Ripper
     oper.merge!(
       type: :kwrest_param,
       body: [ident],
-      end: ident[:end],
-      char_end: ident[:char_end]
+      el: ident[:el],
+      ec: ident[:ec]
     )
   end
 
@@ -1384,23 +1359,23 @@ class Prettier::Parser < Ripper
   def on_lambda(params, stmts)
     beging = find_scanner_event(:@tlambda)
 
-    if scanner_events.any? { |event| event[:type] == :@tlambeg }
-      opening = find_scanner_event(:@tlambeg)
+    if event = find_scanner_event(:@tlambeg, consume: false)
+      opening = scanner_events.delete(event)
       closing = find_scanner_event(:@rbrace)
     else
       opening = find_scanner_event(:@kw, 'do')
       closing = find_scanner_event(:@kw, 'end')
     end
 
-    stmts.bind(opening[:char_end], closing[:char_start])
+    stmts.bind(opening[:ec], closing[:sc])
 
     {
       type: :lambda,
       body: [params, stmts],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: closing[:end],
-      char_end: closing[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: closing[:el],
+      ec: closing[:ec]
     }
   end
 
@@ -1422,17 +1397,15 @@ class Prettier::Parser < Ripper
   # in which case we need to explicitly track the comma and add it onto the
   # child node.
   def on_massign(left, right)
-    if source[left[:char_end]...right[:char_start]].strip.start_with?(',')
-      left[:comma] = true
-    end
+    left[:comma] = true if source[left[:ec]...right[:sc]].strip.start_with?(',')
 
     {
       type: :massign,
       body: [left, right],
-      start: left[:start],
-      char_start: left[:char_start],
-      end: right[:end],
-      char_end: right[:char_end]
+      sl: left[:sl],
+      sc: left[:sc],
+      el: right[:el],
+      ec: right[:ec]
     }
   end
 
@@ -1451,10 +1424,10 @@ class Prettier::Parser < Ripper
     {
       type: :method_add_arg,
       body: [fcall, arg_paren],
-      start: fcall[:start],
-      char_start: fcall[:char_start],
-      end: arg_paren[:end],
-      char_end: arg_paren[:char_end]
+      sl: fcall[:sl],
+      sc: fcall[:sc],
+      el: arg_paren[:el],
+      ec: arg_paren[:ec]
     }
   end
 
@@ -1465,10 +1438,10 @@ class Prettier::Parser < Ripper
     {
       type: :method_add_block,
       body: [method_add_arg, block],
-      start: method_add_arg[:start],
-      char_start: method_add_arg[:char_start],
-      end: block[:end],
-      char_end: block[:char_end]
+      sl: method_add_arg[:sl],
+      sc: method_add_arg[:sc],
+      el: block[:el],
+      ec: block[:ec]
     }
   end
 
@@ -1479,10 +1452,10 @@ class Prettier::Parser < Ripper
     {
       type: :mlhs,
       body: [],
-      start: lineno,
-      char_start: char_pos,
-      end: lineno,
-      char_end: char_pos
+      sl: lineno,
+      sc: char_pos,
+      el: lineno,
+      ec: char_pos
     }
   end
 
@@ -1493,11 +1466,7 @@ class Prettier::Parser < Ripper
     if mlhs[:body].empty?
       part.merge(type: :mlhs, body: [part])
     else
-      mlhs.merge!(
-        body: mlhs[:body] << part,
-        end: part[:end],
-        char_end: part[:char_end]
-      )
+      mlhs.merge!(body: mlhs[:body] << part, el: part[:el], ec: part[:ec])
     end
   end
 
@@ -1510,8 +1479,8 @@ class Prettier::Parser < Ripper
     mlhs_add_star.merge(
       type: :mlhs_add_post,
       body: [mlhs_add_star, mlhs],
-      end: mlhs[:end],
-      char_end: mlhs[:char_end]
+      el: mlhs[:el],
+      ec: mlhs[:ec]
     )
   end
 
@@ -1526,10 +1495,10 @@ class Prettier::Parser < Ripper
     {
       type: :mlhs_add_star,
       body: [mlhs, part],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1541,17 +1510,17 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@lparen)
     ending = find_scanner_event(:@rparen)
 
-    if source[beging[:char_end]...ending[:char_start]].strip.end_with?(',')
+    if source[beging[:ec]...ending[:sc]].strip.end_with?(',')
       contents[:comma] = true
     end
 
     {
       type: :mlhs_paren,
       body: [contents],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1562,18 +1531,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'module')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(
-      find_next_statement_start(const[:char_end]),
-      ending[:char_start]
-    )
+    bodystmt.bind(find_next_statement_start(const[:ec]), ending[:sc])
 
     {
       type: :module,
       body: [const, bodystmt],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1585,10 +1551,10 @@ class Prettier::Parser < Ripper
     {
       type: :mrhs,
       body: [],
-      start: lineno,
-      char_start: char_pos,
-      end: lineno,
-      char_end: char_pos
+      sl: lineno,
+      sc: char_pos,
+      el: lineno,
+      ec: char_pos
     }
   end
 
@@ -1598,11 +1564,7 @@ class Prettier::Parser < Ripper
     if mrhs[:body].empty?
       part.merge(type: :mrhs, body: [part])
     else
-      mrhs.merge!(
-        body: mrhs[:body] << part,
-        end: part[:end],
-        char_end: part[:char_end]
-      )
+      mrhs.merge!(body: mrhs[:body] << part, el: part[:el], ec: part[:ec])
     end
   end
 
@@ -1616,10 +1578,10 @@ class Prettier::Parser < Ripper
     {
       type: :mrhs_add_star,
       body: [mrhs, part],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1642,8 +1604,8 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'next').merge!(
       type: :next,
       body: [args_add_block],
-      end: args_add_block[:end],
-      char_end: args_add_block[:char_end]
+      el: args_add_block[:el],
+      ec: args_add_block[:ec]
     )
   end
 
@@ -1655,8 +1617,8 @@ class Prettier::Parser < Ripper
     left.merge(
       type: :opassign,
       body: [left, oper, right],
-      end: right[:end],
-      char_end: right[:char_end]
+      el: right[:el],
+      ec: right[:ec]
     )
   end
 
@@ -1670,13 +1632,13 @@ class Prettier::Parser < Ripper
     location =
       if flattened.any?
         {
-          start: flattened[0][:start],
-          char_start: flattened[0][:char_start],
-          end: flattened[-1][:end],
-          char_end: flattened[-1][:char_end]
+          sl: flattened[0][:sl],
+          sc: flattened[0][:sc],
+          el: flattened[-1][:el],
+          ec: flattened[-1][:ec]
         }
       else
-        { start: lineno, char_start: char_pos, end: lineno, char_end: char_pos }
+        { sl: lineno, sc: char_pos, el: lineno, ec: char_pos }
       end
 
     location.merge!(type: :params, body: types)
@@ -1686,13 +1648,18 @@ class Prettier::Parser < Ripper
   # anywhere in a Ruby program. It accepts as arguments the contents, which
   # can be either params or statements.
   def on_paren(contents)
+    beging = find_scanner_event(:@lparen)
     ending = find_scanner_event(:@rparen)
 
-    find_scanner_event(:@lparen).merge!(
+    if contents && contents[:type] == :params
+      contents.merge!(sc: beging[:ec], ec: ending[:sc])
+    end
+
+    beging.merge!(
       type: :paren,
       body: [contents],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      el: ending[:el],
+      ec: ending[:ec]
     )
   end
 
@@ -1701,12 +1668,7 @@ class Prettier::Parser < Ripper
   # source string. We'll also attach on the __END__ content if there was
   # 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
-    }
+    range = { sl: 1, el: lines.length, sc: 0, ec: source.length }
 
     stmts[:body] << @__end__ if @__end__
     stmts.bind(0, source.length)
@@ -1728,8 +1690,8 @@ class Prettier::Parser < Ripper
   def on_qsymbols_add(qsymbols, tstring_content)
     qsymbols.merge!(
       body: qsymbols[:body] << tstring_content,
-      end: tstring_content[:end],
-      char_end: tstring_content[:char_end]
+      el: tstring_content[:el],
+      ec: tstring_content[:ec]
     )
   end
 
@@ -1747,8 +1709,8 @@ class Prettier::Parser < Ripper
   def on_qwords_add(qwords, tstring_content)
     qwords.merge!(
       body: qwords[:body] << tstring_content,
-      end: tstring_content[:end],
-      char_end: tstring_content[:char_end]
+      el: tstring_content[:el],
+      ec: tstring_content[:ec]
     )
   end
 
@@ -1773,8 +1735,8 @@ class Prettier::Parser < Ripper
   def on_regexp_add(regexp, piece)
     regexp.merge!(
       body: regexp[:body] << piece,
-      end: regexp[:end],
-      char_end: regexp[:char_end]
+      el: regexp[:el],
+      ec: regexp[:ec]
     )
   end
 
@@ -1786,8 +1748,8 @@ class Prettier::Parser < Ripper
     regexp.merge!(
       type: :regexp_literal,
       ending: ending[:body],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      el: ending[:el],
+      ec: ending[:ec]
     )
   end
 
@@ -1796,17 +1758,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_end(char_end)
-      merge!(char_end: char_end)
+    def bind_end(ec)
+      merge!(ec: ec)
 
       stmts = self[:body][2]
       consequent = self[:body][3]
 
       if consequent
-        consequent.bind_end(char_end)
-        stmts.bind_end(consequent[:char_start])
+        consequent.bind_end(ec)
+        stmts.bind_end(consequent[:sc])
       else
-        stmts.bind_end(char_end)
+        stmts.bind_end(ec)
       end
     end
   end
@@ -1819,14 +1781,14 @@ class Prettier::Parser < Ripper
     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)
+    stmts.bind(find_next_statement_start(last_node[:ec]), char_pos)
 
     Rescue.new(
       beging.merge!(
         type: :rescue,
         body: [exceptions, variable, stmts, consequent],
-        end: lineno,
-        char_end: char_pos
+        el: lineno,
+        ec: char_pos
       )
     )
   end
@@ -1840,10 +1802,10 @@ class Prettier::Parser < Ripper
     {
       type: :rescue_mod,
       body: [statement, rescued],
-      start: statement[:start],
-      char_start: statement[:char_start],
-      end: rescued[:end],
-      char_end: rescued[:char_end]
+      sl: statement[:sl],
+      sc: statement[:sc],
+      el: rescued[:el],
+      ec: rescued[:ec]
     }
   end
 
@@ -1858,8 +1820,8 @@ class Prettier::Parser < Ripper
     oper.merge!(
       type: :rest_param,
       body: [ident],
-      end: ident[:end],
-      char_end: ident[:char_end]
+      el: ident[:el],
+      ec: ident[:ec]
     )
   end
 
@@ -1876,8 +1838,8 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'return').merge!(
       type: :return,
       body: [args_add_block],
-      end: args_add_block[:end],
-      char_end: args_add_block[:char_end]
+      el: args_add_block[:el],
+      ec: args_add_block[:ec]
     )
   end
 
@@ -1903,18 +1865,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'class')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(
-      find_next_statement_start(target[:char_end]),
-      ending[:char_start]
-    )
+    bodystmt.bind(find_next_statement_start(target[:ec]), ending[:sc])
 
     {
       type: :sclass,
       body: [target, bodystmt],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -1926,23 +1885,23 @@ class Prettier::Parser < Ripper
   # propagate that onto void_stmt nodes inside the stmts in order to make sure
   # all comments get printed appropriately.
   class Stmts < SimpleDelegator
-    def bind(char_start, char_end)
-      merge!(char_start: char_start, char_end: char_end)
+    def bind(sc, ec)
+      merge!(sc: sc, ec: ec)
 
       if self[:body][0][:type] == :void_stmt
-        self[:body][0].merge!(char_start: char_start, char_end: char_start)
+        self[:body][0].merge!(sc: sc, ec: sc)
       end
     end
 
-    def bind_end(char_end)
-      merge!(char_end: char_end)
+    def bind_end(ec)
+      merge!(ec: ec)
     end
 
     def <<(statement)
       if self[:body].any?
-        merge!(statement.slice(:end, :char_end))
+        merge!(statement.slice(:el, :ec))
       else
-        merge!(statement.slice(:start, :end, :char_start, :char_end))
+        merge!(statement.slice(:sl, :el, :sc, :ec))
       end
 
       self[:body] << statement
@@ -1957,10 +1916,10 @@ class Prettier::Parser < Ripper
     Stmts.new(
       type: :stmts,
       body: [],
-      start: lineno,
-      end: lineno,
-      char_start: char_pos,
-      char_end: char_pos
+      sl: lineno,
+      el: lineno,
+      sc: char_pos,
+      ec: char_pos
     )
   end
 
@@ -1982,10 +1941,10 @@ class Prettier::Parser < Ripper
     {
       type: :string_concat,
       body: [left, right],
-      start: left[:start],
-      char_start: left[:char_start],
-      end: right[:end],
-      char_end: right[:char_end]
+      sl: left[:sl],
+      sc: left[:sc],
+      el: right[:el],
+      ec: right[:ec]
     }
   end
 
@@ -1998,10 +1957,10 @@ class Prettier::Parser < Ripper
     {
       type: :string,
       body: [],
-      start: lineno,
-      end: lineno,
-      char_start: char_pos,
-      char_end: char_pos
+      sl: lineno,
+      el: lineno,
+      sc: char_pos,
+      ec: char_pos
     }
   end
 
@@ -2010,11 +1969,7 @@ class Prettier::Parser < Ripper
   # It accepts as arguments the parent string node as well as the additional
   # piece of the string.
   def on_string_add(string, piece)
-    string.merge!(
-      body: string[:body] << piece,
-      end: piece[:end],
-      char_end: piece[:char_end]
-    )
+    string.merge!(body: string[:body] << piece, el: piece[:el], ec: piece[:ec])
   end
 
   # string_dvar is a parser event that represents a very special kind of
@@ -2026,8 +1981,8 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@embvar).merge!(
       type: :string_dvar,
       body: [var_ref],
-      end: var_ref[:end],
-      char_end: var_ref[:char_end]
+      el: var_ref[:el],
+      ec: var_ref[:ec]
     )
   end
 
@@ -2039,15 +1994,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@embexpr_beg)
     ending = find_scanner_event(:@embexpr_end)
 
-    stmts.bind(beging[:char_end], ending[:char_start])
+    stmts.bind(beging[:ec], ending[:sc])
 
     {
       type: :string_embexpr,
       body: [stmts],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -2066,10 +2021,10 @@ class Prettier::Parser < Ripper
         type: :string_literal,
         body: string[:body],
         quote: beging[:body],
-        start: beging[:start],
-        char_start: beging[:char_start],
-        end: ending[:end],
-        char_end: ending[:char_end]
+        sl: beging[:sl],
+        sc: beging[:sc],
+        el: ending[:el],
+        ec: ending[:ec]
       }
     end
   end
@@ -2082,8 +2037,8 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'super').merge!(
       type: :super,
       body: [contents],
-      end: contents[:end],
-      char_end: contents[:char_end]
+      el: contents[:el],
+      ec: contents[:ec]
     )
   end
 
@@ -2114,7 +2069,7 @@ class Prettier::Parser < Ripper
       contents.merge(type: :symbol_literal, body: [contents])
     else
       beging = find_scanner_event(:@symbeg)
-      contents.merge!(type: :symbol_literal, char_start: beging[:char_start])
+      contents.merge!(type: :symbol_literal, sc: beging[:sc])
     end
   end
 
@@ -2133,8 +2088,8 @@ class Prettier::Parser < Ripper
   def on_symbols_add(symbols, word_add)
     symbols.merge!(
       body: symbols[:body] << word_add,
-      end: word_add[:end],
-      char_end: word_add[:char_end]
+      el: word_add[:el],
+      ec: word_add[:ec]
     )
   end
 
@@ -2145,8 +2100,7 @@ class Prettier::Parser < Ripper
   def find_colon2_before(const)
     index =
       scanner_events.rindex do |event|
-        event[:type] == :@op && event[:body] == '::' &&
-          event[:char_start] < const[:char_start]
+        event[:type] == :@op && event[:body] == '::' && event[:sc] < const[:sc]
       end
 
     scanner_events[index]
@@ -2163,8 +2117,8 @@ class Prettier::Parser < Ripper
     const.merge(
       type: :top_const_field,
       body: [const],
-      start: beging[:start],
-      char_start: beging[:char_start]
+      sl: beging[:sl],
+      sc: beging[:sc]
     )
   end
 
@@ -2179,8 +2133,8 @@ class Prettier::Parser < Ripper
     const.merge(
       type: :top_const_ref,
       body: [const],
-      start: beging[:start],
-      char_start: beging[:char_start]
+      sl: beging[:sl],
+      sc: beging[:sc]
     )
   end
 
@@ -2192,15 +2146,15 @@ class Prettier::Parser < Ripper
     if oper == :not
       node = find_scanner_event(:@kw, 'not')
 
-      paren = source[node[:char_end]...value[:char_start]].include?('(')
+      paren = source[node[:ec]...value[:sc]].include?('(')
       ending = paren ? find_scanner_event(:@rparen) : value
 
       node.merge!(
         type: :unary,
         oper: oper,
         body: [value],
-        end: ending[:end],
-        char_end: ending[:char_end],
+        el: ending[:el],
+        ec: ending[:ec],
         paren: paren
       )
     else
@@ -2210,7 +2164,7 @@ class Prettier::Parser < Ripper
       # stack. So we need to explicitly disallow those operators.
       index =
         scanner_events.rindex do |scanner_event|
-          scanner_event[:type] == :@op &&
+          scanner_event[:type] == :@op && scanner_event[:sc] < value[:sc] &&
             !%w[.. ...].include?(scanner_event[:body])
         end
 
@@ -2219,8 +2173,8 @@ class Prettier::Parser < Ripper
         type: :unary,
         oper: oper[0],
         body: [value],
-        end: value[:end],
-        char_end: value[:char_end]
+        el: value[:el],
+        ec: value[:ec]
       )
     end
   end
@@ -2235,8 +2189,8 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'undef').merge!(
       type: :undef,
       body: symbol_literals,
-      end: last[:end],
-      char_end: last[:char_end]
+      el: last[:el],
+      ec: last[:ec]
     )
   end
 
@@ -2248,15 +2202,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'unless')
     ending = consequent || find_scanner_event(:@kw, 'end')
 
-    stmts.bind(predicate[:char_end], ending[:char_start])
+    stmts.bind(predicate[:ec], ending[:sc])
 
     {
       type: :unless,
       body: [predicate, stmts, consequent],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -2269,10 +2223,10 @@ class Prettier::Parser < Ripper
     {
       type: :unless_mod,
       body: [predicate, statement],
-      start: statement[:start],
-      char_start: statement[:char_start],
-      end: predicate[:end],
-      char_end: predicate[:char_end]
+      sl: statement[:sl],
+      sc: statement[:sc],
+      el: predicate[:el],
+      ec: predicate[:ec]
     }
   end
 
@@ -2283,15 +2237,22 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'until')
     ending = find_scanner_event(:@kw, 'end')
 
-    stmts.bind(predicate[:char_end], ending[:char_start])
+    # Consume the do keyword if it exists so that it doesn't get confused for
+    # some other block
+    do_event = find_scanner_event(:@kw, 'do', consume: false)
+    if do_event && do_event[:sc] > predicate[:ec] && do_event[:ec] < ending[:sc]
+      scanner_events.delete(do_event)
+    end
+
+    stmts.bind(predicate[:ec], ending[:sc])
 
     {
       type: :until,
       body: [predicate, stmts],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -2304,10 +2265,10 @@ class Prettier::Parser < Ripper
     {
       type: :until_mod,
       body: [predicate, statement],
-      start: statement[:start],
-      char_start: statement[:char_start],
-      end: predicate[:end],
-      char_end: predicate[:char_end]
+      sl: statement[:sl],
+      sc: statement[:sc],
+      el: predicate[:el],
+      ec: predicate[:ec]
     }
   end
 
@@ -2318,16 +2279,16 @@ class Prettier::Parser < Ripper
   def on_var_alias(left, right)
     beging = find_scanner_event(:@kw, 'alias')
 
-    paren = source[beging[:char_end]...left[:char_start]].include?('(')
+    paren = source[beging[:ec]...left[:sc]].include?('(')
     ending = paren ? find_scanner_event(:@rparen) : right
 
     {
       type: :var_alias,
       body: [left, right],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -2379,13 +2340,7 @@ class Prettier::Parser < Ripper
   # block of code. It often will have comments attached to it, so it requires
   # some special handling.
   def on_void_stmt
-    {
-      type: :void_stmt,
-      start: lineno,
-      end: lineno,
-      char_start: char_pos,
-      char_end: char_pos
-    }
+    { type: :void_stmt, sl: lineno, el: lineno, sc: char_pos, ec: char_pos }
   end
 
   # when is a parser event that represents another clause in a case chain.
@@ -2396,15 +2351,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'when')
     ending = consequent || find_scanner_event(:@kw, 'end')
 
-    stmts.bind(predicate[:char_end], ending[:char_start])
+    stmts.bind(predicate[:ec], ending[:sc])
 
     {
       type: :when,
       body: [predicate, stmts, consequent],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -2415,15 +2370,22 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'while')
     ending = find_scanner_event(:@kw, 'end')
 
-    stmts.bind(predicate[:char_end], ending[:char_start])
+    # Consume the do keyword if it exists so that it doesn't get confused for
+    # some other block
+    do_event = find_scanner_event(:@kw, 'do', consume: false)
+    if do_event && do_event[:sc] > predicate[:ec] && do_event[:ec] < ending[:sc]
+      scanner_events.delete(do_event)
+    end
+
+    stmts.bind(predicate[:ec], ending[:sc])
 
     {
       type: :while,
       body: [predicate, stmts],
-      start: beging[:start],
-      char_start: beging[:char_start],
-      end: ending[:end],
-      char_end: ending[:char_end]
+      sl: beging[:sl],
+      sc: beging[:sc],
+      el: ending[:el],
+      ec: ending[:ec]
     }
   end
 
@@ -2436,10 +2398,10 @@ class Prettier::Parser < Ripper
     {
       type: :while_mod,
       body: [predicate, statement],
-      start: statement[:start],
-      char_start: statement[:char_start],
-      end: predicate[:end],
-      char_end: predicate[:char_end]
+      sl: statement[:sl],
+      sc: statement[:sc],
+      el: predicate[:el],
+      ec: predicate[:ec]
     }
   end
 
@@ -2469,11 +2431,7 @@ class Prettier::Parser < Ripper
       # location information from the first piece.
       piece.merge(type: :word, body: [piece])
     else
-      word.merge!(
-        body: word[:body] << piece,
-        end: piece[:end],
-        char_end: piece[:char_end]
-      )
+      word.merge!(body: word[:body] << piece, el: piece[:el], ec: piece[:ec])
     end
   end
 
@@ -2492,8 +2450,8 @@ class Prettier::Parser < Ripper
   def on_words_add(words, word_add)
     words.merge!(
       body: words[:body] << word_add,
-      end: word_add[:end],
-      char_end: word_add[:char_end]
+      el: word_add[:el],
+      ec: word_add[:ec]
     )
   end
 
@@ -2526,8 +2484,8 @@ class Prettier::Parser < Ripper
   def on_xstring_add(xstring, piece)
     xstring.merge!(
       body: xstring[:body] << piece,
-      end: piece[:end],
-      char_end: piece[:char_end]
+      el: piece[:el],
+      ec: piece[:ec]
     )
   end
 
@@ -2552,11 +2510,7 @@ class Prettier::Parser < Ripper
       heredoc.merge!(body: xstring[:body])
     else
       ending = find_scanner_event(:@tstring_end)
-      xstring.merge!(
-        type: :xstring_literal,
-        end: ending[:end],
-        char_end: ending[:char_end]
-      )
+      xstring.merge!(type: :xstring_literal, el: ending[:el], ec: ending[:ec])
     end
   end
 
@@ -2567,8 +2521,8 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'yield').merge!(
       type: :yield,
       body: [args_add_block],
-      end: args_add_block[:end],
-      char_end: args_add_block[:char_end]
+      el: args_add_block[:el],
+      ec: args_add_block[:ec]
     )
   end