prettier 1.2.3 → 1.5.0

data/src/ruby/nodes/strings.js

@@ -4,6 +4,7 @@ const {
   hardline,
   indent,
   literalline,
+  removeLines,
   softline,
   join
 } = require("../../prettier");
@@ -31,17 +32,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 +91,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 node = path.getValue();
+  const parts = path.call(print, "body", 0);
+
+  // If the contents of this embedded expression were originally on the same
+  // line in the source, then we're going to leave them in place and assume
+  // that's the way the developer wanted this expression represented.
+  if (node.sl === node.el) {
+    return concat(["#{", removeLines(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 +147,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 +168,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/ruby/parser.js

@@ -1,58 +1,11 @@
-const { spawnSync } = require("child_process");
-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.
-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];
-})();
+const parseSync = require("../parser/parseSync");
 
 // 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
 // the code stored in that string. We accomplish this by spawning a new Ruby
 // process of parser.rb and reading JSON off STDOUT.
 function parse(text, _parsers, _opts) {
-  const child = spawnSync(
-    "ruby",
-    ["--disable-gems", path.join(__dirname, "./parser.rb")],
-    {
-      env: Object.assign({}, process.env, { LANG }),
-      input: text,
-      maxBuffer: 10 * 1024 * 1024 // 10MB
-    }
-  );
-
-  const error = child.stderr.toString();
-  if (error) {
-    throw new Error(error);
-  }
-
-  const response = child.stdout.toString();
-  return JSON.parse(response);
+  return parseSync("ruby", text);
 }
 
 const pragmaPattern = /#\s*@(prettier|format)/;

data/src/ruby/parser.rb

@@ -14,14 +14,19 @@ if (RUBY_MAJOR < 2) || ((RUBY_MAJOR == 2) && (RUBY_MINOR < 5))
 end
 
 require 'delegate'
-require 'json' unless defined?(JSON)
+require 'json'
 require 'ripper'
 
-module Prettier; end
+module Prettier
+end
 
 class Prettier::Parser < Ripper
   attr_reader :source, :lines, :scanner_events, :line_counts
 
+  # This is an attr_accessor so Stmts objects can grab comments out of this
+  # array and attach them to themselves.
+  attr_accessor :comments
+
   def initialize(source, *args)
     super(source, *args)
 
@@ -40,6 +45,13 @@ class Prettier::Parser < Ripper
     @source.lines.each { |line| @line_counts << @line_counts.last + line.size }
   end
 
+  def self.parse(source)
+    builder = new(source)
+
+    response = builder.parse
+    response unless builder.error?
+  end
+
   private
 
   # This represents the current place in the source string that we've gotten to
@@ -93,8 +105,8 @@ class Prettier::Parser < Ripper
       node = {
         type: :"@#{event}",
         body: value,
-        start: lineno,
-        end: lineno,
+        sl: lineno,
+        el: lineno,
         sc: char_pos,
         ec: ec
       }
@@ -118,8 +130,9 @@ class Prettier::Parser < Ripper
     @comments << {
       type: :@comment,
       value: value[1..-1].chomp.force_encoding('UTF-8'),
-      start: lineno,
-      end: lineno,
+      inline: value.strip != lines[lineno - 1],
+      sl: lineno,
+      el: lineno,
       sc: char_pos,
       ec: char_pos + value.length - 1
     }
@@ -138,8 +151,8 @@ class Prettier::Parser < Ripper
     {
       type: :ignored_nl,
       body: nil,
-      start: lineno,
-      end: lineno,
+      sl: lineno,
+      el: lineno,
       sc: char_pos,
       ec: char_pos
     }
@@ -191,7 +204,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'BEGIN').merge!(
       type: :BEGIN,
       body: [beging, stmts],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     )
   end
@@ -215,7 +228,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'END').merge!(
       type: :END,
       body: [beging, stmts],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     )
   end
@@ -234,9 +247,9 @@ class Prettier::Parser < Ripper
     {
       type: :alias,
       body: [left, right],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -262,9 +275,9 @@ class Prettier::Parser < Ripper
     {
       type: :aref,
       body: [collection, index],
-      start: collection[:start],
+      sl: collection[:sl],
       sc: collection[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -278,9 +291,9 @@ class Prettier::Parser < Ripper
     {
       type: :aref_field,
       body: [collection, index],
-      start: collection[:start],
+      sl: collection[:sl],
       sc: collection[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -292,9 +305,9 @@ class Prettier::Parser < Ripper
     {
       type: :args,
       body: [],
-      start: lineno,
+      sl: lineno,
       sc: char_pos,
-      end: lineno,
+      el: lineno,
       ec: char_pos
     }
   end
@@ -307,7 +320,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], ec: arg[:ec])
+      args.merge!(body: args[:body] << arg, el: arg[:el], ec: arg[:ec])
     end
   end
 
@@ -320,7 +333,7 @@ class Prettier::Parser < Ripper
     args.merge(
       type: :args_add_block,
       body: [args, block],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     )
   end
@@ -335,9 +348,9 @@ class Prettier::Parser < Ripper
     {
       type: :args_add_star,
       body: [args, part],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -357,14 +370,14 @@ 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],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -381,9 +394,9 @@ class Prettier::Parser < Ripper
       {
         type: :array,
         body: [contents],
-        start: beging[:start],
+        sl: beging[:sl],
         sc: beging[:sc],
-        end: ending[:end],
+        el: ending[:el],
         ec: ending[:ec]
       }
     else
@@ -393,7 +406,7 @@ class Prettier::Parser < Ripper
       ending.merge!(
         type: :array,
         body: [contents],
-        start: contents[:start],
+        sl: contents[:sl],
         sc: contents[:sc]
       )
     end
@@ -407,9 +420,9 @@ class Prettier::Parser < Ripper
     {
       type: :aryptn,
       body: [const, preargs, splatarg, postargs],
-      start: pieces[0][:start],
+      sl: pieces[0][:sl],
       sc: pieces[0][:sc],
-      end: pieces[-1][:end],
+      el: pieces[-1][:el],
       ec: pieces[-1][:ec]
     }
   end
@@ -421,7 +434,7 @@ class Prettier::Parser < Ripper
     left.merge(
       type: :assign,
       body: [left, right],
-      end: right[:end],
+      el: right[:el],
       ec: right[:ec]
     )
   end
@@ -433,9 +446,9 @@ class Prettier::Parser < Ripper
     {
       type: :assoc_new,
       body: [key, value],
-      start: key[:start],
+      sl: key[:sl],
       sc: key[:sc],
-      end: value[:end],
+      el: value[:el],
       ec: value[:ec]
     }
   end
@@ -446,7 +459,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@op, '**').merge!(
       type: :assoc_splat,
       body: [contents],
-      end: contents[:end],
+      el: contents[:el],
       ec: contents[:ec]
     )
   end
@@ -459,9 +472,9 @@ class Prettier::Parser < Ripper
     {
       type: :assoclist_from_args,
       body: assocs,
-      start: assocs[0][:start],
+      sl: assocs[0][:sl],
       sc: assocs[0][:sc],
-      end: assocs[-1][:end],
+      el: assocs[-1][:el],
       ec: assocs[-1][:ec]
     }
   end
@@ -474,9 +487,9 @@ class Prettier::Parser < Ripper
     {
       type: :bare_assoc_hash,
       body: assoc_news,
-      start: assoc_news[0][:start],
+      sl: assoc_news[0][:sl],
       sc: assoc_news[0][:sc],
-      end: assoc_news[-1][:end],
+      el: assoc_news[-1][:el],
       ec: assoc_news[-1][:ec]
     }
   end
@@ -497,7 +510,7 @@ class Prettier::Parser < Ripper
     beging.merge!(
       type: :begin,
       body: [bodystmt],
-      end: bodystmt[:end],
+      el: bodystmt[:el],
       ec: bodystmt[:ec]
     )
   end
@@ -508,9 +521,9 @@ class Prettier::Parser < Ripper
     {
       type: :binary,
       body: [left, oper, right],
-      start: left[:start],
+      sl: left[:sl],
       sc: left[:sc],
-      end: right[:end],
+      el: right[:el],
       ec: right[:ec]
     }
   end
@@ -530,9 +543,9 @@ class Prettier::Parser < Ripper
     {
       type: :block_var,
       body: [params, locals],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -543,7 +556,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@op, '&').merge!(
       type: :blockarg,
       body: [ident],
-      end: ident[:end],
+      el: ident[:el],
       ec: ident[:ec]
     )
   end
@@ -574,9 +587,9 @@ class Prettier::Parser < Ripper
     BodyStmt.new(
       type: :bodystmt,
       body: [stmts, rescued, ensured, elsed],
-      start: lineno,
+      sl: lineno,
       sc: char_pos,
-      end: lineno,
+      el: lineno,
       ec: char_pos
     )
   end
@@ -594,9 +607,9 @@ class Prettier::Parser < Ripper
     {
       type: :brace_block,
       body: [block_var, stmts],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -617,7 +630,7 @@ class Prettier::Parser < Ripper
     beging.merge!(
       type: :break,
       body: [args_add_block],
-      end: args_add_block[:end],
+      el: args_add_block[:el],
       ec: args_add_block[:ec]
     )
   end
@@ -634,10 +647,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
@@ -651,9 +660,9 @@ class Prettier::Parser < Ripper
     {
       type: :call,
       body: [receiver, oper, sending],
-      start: receiver[:start],
+      sl: receiver[:sl],
       sc: receiver[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -672,7 +681,7 @@ class Prettier::Parser < Ripper
 
     beging.merge!(
       body: [switch, consequent],
-      end: consequent[:end],
+      el: consequent[:el],
       ec: consequent[:ec]
     )
   end
@@ -714,9 +723,9 @@ class Prettier::Parser < Ripper
     {
       type: :class,
       body: [const, superclass, bodystmt],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -728,9 +737,9 @@ class Prettier::Parser < Ripper
     {
       type: :command,
       body: [ident, args],
-      start: ident[:start],
+      sl: ident[:sl],
       sc: ident[:sc],
-      end: args[:end],
+      el: args[:el],
       ec: args[:ec]
     }
   end
@@ -740,19 +749,14 @@ class Prettier::Parser < Ripper
   # of the method, the operator being used to send the method, the name of
   # the method, and the arguments being passed to the method.
   def on_command_call(receiver, oper, ident, args)
-    # 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)
-
-    # Grab the ending from either the arguments or the method being sent
     ending = args || ident
 
     {
       type: :command_call,
       body: [receiver, oper, ident, args],
-      start: receiver[:start],
+      sl: receiver[:sl],
       sc: receiver[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -767,9 +771,9 @@ class Prettier::Parser < Ripper
     {
       type: :const_path_field,
       body: [left, const],
-      start: left[:start],
+      sl: left[:sl],
       sc: left[:sc],
-      end: const[:end],
+      el: const[:el],
       ec: const[:ec]
     }
   end
@@ -784,9 +788,9 @@ class Prettier::Parser < Ripper
     {
       type: :const_path_ref,
       body: [left, const],
-      start: left[:start],
+      sl: left[:sl],
       sc: left[:sc],
-      end: const[:end],
+      el: const[:el],
       ec: const[:ec]
     }
   end
@@ -837,9 +841,9 @@ class Prettier::Parser < Ripper
         {
           type: :defsl,
           body: [ident, params, bodystmt],
-          start: beging[:start],
+          sl: beging[:sl],
           sc: beging[:sc],
-          end: bodystmt[:end],
+          el: bodystmt[:el],
           ec: bodystmt[:ec]
         }
       )
@@ -857,9 +861,9 @@ class Prettier::Parser < Ripper
     {
       type: :def,
       body: [ident, params, bodystmt],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -897,9 +901,9 @@ class Prettier::Parser < Ripper
     {
       type: :defs,
       body: [target, oper, ident, params, bodystmt],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -917,7 +921,7 @@ class Prettier::Parser < Ripper
     beging.merge!(
       type: :defined,
       body: [value],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     )
   end
@@ -935,9 +939,9 @@ class Prettier::Parser < Ripper
     {
       type: :do_block,
       body: [block_var, bodystmt],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -954,9 +958,9 @@ class Prettier::Parser < Ripper
     {
       type: :dot2,
       body: [left, right],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -973,9 +977,9 @@ class Prettier::Parser < Ripper
     {
       type: :dot3,
       body: [left, right],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1008,7 +1012,7 @@ class Prettier::Parser < Ripper
         type: :dyna_symbol,
         quote: beging[:body][1],
         body: string[:body],
-        end: ending[:end],
+        el: ending[:el],
         ec: ending[:ec]
       )
     else
@@ -1019,9 +1023,9 @@ class Prettier::Parser < Ripper
       string.merge!(
         type: :dyna_symbol,
         quote: ending[:body][0],
-        start: beging[:start],
+        sl: beging[:sl],
         sc: beging[:sc],
-        end: ending[:end],
+        el: ending[:el],
         ec: ending[:ec]
       )
     end
@@ -1052,9 +1056,9 @@ class Prettier::Parser < Ripper
     {
       type: :else,
       body: [stmts],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1072,9 +1076,9 @@ class Prettier::Parser < Ripper
     {
       type: :elsif,
       body: [predicate, stmts, consequent],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1085,7 +1089,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, sc: 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
@@ -1104,7 +1108,7 @@ class Prettier::Parser < Ripper
     @comments <<
       @embdoc.merge!(
         value: @embdoc[:value] << value.chomp,
-        end: lineno,
+        el: lineno,
         ec: char_pos + value.length - 1
       )
 
@@ -1129,9 +1133,9 @@ class Prettier::Parser < Ripper
     {
       type: :ensure,
       body: [beging, stmts],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1160,9 +1164,9 @@ class Prettier::Parser < Ripper
     {
       type: :field,
       body: [left, oper, right],
-      start: left[:start],
+      sl: left[:sl],
       sc: left[:sc],
-      end: right[:end],
+      el: right[:el],
       ec: right[:ec]
     }
   end
@@ -1176,9 +1180,9 @@ class Prettier::Parser < Ripper
     {
       type: :fndptn,
       body: [const, presplat, args, postsplat],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1196,9 +1200,9 @@ class Prettier::Parser < Ripper
     {
       type: :for,
       body: [ident, enumerable, stmts],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1219,9 +1223,9 @@ class Prettier::Parser < Ripper
     {
       type: :hash,
       body: [assoclist_from_args],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1234,8 +1238,8 @@ class Prettier::Parser < Ripper
   # printer through our embed function.
   def on_heredoc_beg(beging)
     location = {
-      start: lineno,
-      end: lineno,
+      sl: lineno,
+      el: lineno,
       sc: char_pos,
       ec: char_pos + beging.length + 1
     }
@@ -1259,7 +1263,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, ec: 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
@@ -1270,9 +1274,9 @@ class Prettier::Parser < Ripper
     {
       type: :hshptn,
       body: [const, kw, kwrest],
-      start: pieces[0][:start],
+      sl: pieces[0][:sl],
       sc: pieces[0][:sc],
-      end: pieces[-1][:end],
+      el: pieces[-1][:el],
       ec: pieces[-1][:ec]
     }
   end
@@ -1289,9 +1293,9 @@ class Prettier::Parser < Ripper
     {
       type: :if,
       body: [predicate, stmts, consequent],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1303,7 +1307,7 @@ class Prettier::Parser < Ripper
     predicate.merge(
       type: :ifop,
       body: [predicate, truthy, falsy],
-      end: falsy[:end],
+      el: falsy[:el],
       ec: falsy[:ec]
     )
   end
@@ -1317,9 +1321,9 @@ class Prettier::Parser < Ripper
     {
       type: :if_mod,
       body: [predicate, statement],
-      start: statement[:start],
+      sl: statement[:sl],
       sc: statement[:sc],
-      end: predicate[:end],
+      el: predicate[:el],
       ec: predicate[:ec]
     }
   end
@@ -1339,7 +1343,7 @@ class Prettier::Parser < Ripper
     beging.merge!(
       type: :in,
       body: [pattern, stmts, consequent],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     )
   end
@@ -1353,7 +1357,7 @@ class Prettier::Parser < Ripper
     oper.merge!(
       type: :kwrest_param,
       body: [ident],
-      end: ident[:end],
+      el: ident[:el],
       ec: ident[:ec]
     )
   end
@@ -1381,9 +1385,9 @@ class Prettier::Parser < Ripper
     {
       type: :lambda,
       body: [params, stmts],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: closing[:end],
+      el: closing[:el],
       ec: closing[:ec]
     }
   end
@@ -1411,9 +1415,9 @@ class Prettier::Parser < Ripper
     {
       type: :massign,
       body: [left, right],
-      start: left[:start],
+      sl: left[:sl],
       sc: left[:sc],
-      end: right[:end],
+      el: right[:el],
       ec: right[:ec]
     }
   end
@@ -1433,9 +1437,9 @@ class Prettier::Parser < Ripper
     {
       type: :method_add_arg,
       body: [fcall, arg_paren],
-      start: fcall[:start],
+      sl: fcall[:sl],
       sc: fcall[:sc],
-      end: arg_paren[:end],
+      el: arg_paren[:el],
       ec: arg_paren[:ec]
     }
   end
@@ -1447,9 +1451,9 @@ class Prettier::Parser < Ripper
     {
       type: :method_add_block,
       body: [method_add_arg, block],
-      start: method_add_arg[:start],
+      sl: method_add_arg[:sl],
       sc: method_add_arg[:sc],
-      end: block[:end],
+      el: block[:el],
       ec: block[:ec]
     }
   end
@@ -1461,9 +1465,9 @@ class Prettier::Parser < Ripper
     {
       type: :mlhs,
       body: [],
-      start: lineno,
+      sl: lineno,
       sc: char_pos,
-      end: lineno,
+      el: lineno,
       ec: char_pos
     }
   end
@@ -1475,7 +1479,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], ec: part[:ec])
+      mlhs.merge!(body: mlhs[:body] << part, el: part[:el], ec: part[:ec])
     end
   end
 
@@ -1488,7 +1492,7 @@ class Prettier::Parser < Ripper
     mlhs_add_star.merge(
       type: :mlhs_add_post,
       body: [mlhs_add_star, mlhs],
-      end: mlhs[:end],
+      el: mlhs[:el],
       ec: mlhs[:ec]
     )
   end
@@ -1504,9 +1508,9 @@ class Prettier::Parser < Ripper
     {
       type: :mlhs_add_star,
       body: [mlhs, part],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1526,9 +1530,9 @@ class Prettier::Parser < Ripper
     {
       type: :mlhs_paren,
       body: [contents],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1545,9 +1549,9 @@ class Prettier::Parser < Ripper
     {
       type: :module,
       body: [const, bodystmt],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1560,9 +1564,9 @@ class Prettier::Parser < Ripper
     {
       type: :mrhs,
       body: [],
-      start: lineno,
+      sl: lineno,
       sc: char_pos,
-      end: lineno,
+      el: lineno,
       ec: char_pos
     }
   end
@@ -1573,7 +1577,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], ec: part[:ec])
+      mrhs.merge!(body: mrhs[:body] << part, el: part[:el], ec: part[:ec])
     end
   end
 
@@ -1587,9 +1591,9 @@ class Prettier::Parser < Ripper
     {
       type: :mrhs_add_star,
       body: [mrhs, part],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1613,7 +1617,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'next').merge!(
       type: :next,
       body: [args_add_block],
-      end: args_add_block[:end],
+      el: args_add_block[:el],
       ec: args_add_block[:ec]
     )
   end
@@ -1626,7 +1630,7 @@ class Prettier::Parser < Ripper
     left.merge(
       type: :opassign,
       body: [left, oper, right],
-      end: right[:end],
+      el: right[:el],
       ec: right[:ec]
     )
   end
@@ -1641,13 +1645,13 @@ class Prettier::Parser < Ripper
     location =
       if flattened.any?
         {
-          start: flattened[0][:start],
+          sl: flattened[0][:sl],
           sc: flattened[0][:sc],
-          end: flattened[-1][:end],
+          el: flattened[-1][:el],
           ec: flattened[-1][:ec]
         }
       else
-        { start: lineno, sc: char_pos, end: lineno, ec: char_pos }
+        { sl: lineno, sc: char_pos, el: lineno, ec: char_pos }
       end
 
     location.merge!(type: :params, body: types)
@@ -1657,12 +1661,17 @@ 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],
+      el: ending[:el],
       ec: ending[:ec]
     )
   end
@@ -1672,7 +1681,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, sc: 0, ec: source.length }
+    range = { sl: 1, el: lines.length, sc: 0, ec: source.length }
 
     stmts[:body] << @__end__ if @__end__
     stmts.bind(0, source.length)
@@ -1694,7 +1703,7 @@ class Prettier::Parser < Ripper
   def on_qsymbols_add(qsymbols, tstring_content)
     qsymbols.merge!(
       body: qsymbols[:body] << tstring_content,
-      end: tstring_content[:end],
+      el: tstring_content[:el],
       ec: tstring_content[:ec]
     )
   end
@@ -1713,7 +1722,7 @@ class Prettier::Parser < Ripper
   def on_qwords_add(qwords, tstring_content)
     qwords.merge!(
       body: qwords[:body] << tstring_content,
-      end: tstring_content[:end],
+      el: tstring_content[:el],
       ec: tstring_content[:ec]
     )
   end
@@ -1739,7 +1748,7 @@ class Prettier::Parser < Ripper
   def on_regexp_add(regexp, piece)
     regexp.merge!(
       body: regexp[:body] << piece,
-      end: regexp[:end],
+      el: regexp[:el],
       ec: regexp[:ec]
     )
   end
@@ -1752,7 +1761,7 @@ class Prettier::Parser < Ripper
     regexp.merge!(
       type: :regexp_literal,
       ending: ending[:body],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     )
   end
@@ -1765,8 +1774,8 @@ class Prettier::Parser < Ripper
     def bind_end(ec)
       merge!(ec: ec)
 
-      stmts = self[:body][2]
-      consequent = self[:body][3]
+      stmts = self[:body][1]
+      consequent = self[:body][2]
 
       if consequent
         consequent.bind_end(ec)
@@ -1781,17 +1790,31 @@ class Prettier::Parser < Ripper
   # inside of a bodystmt.
   def on_rescue(exceptions, variable, stmts, consequent)
     beging = find_scanner_event(:@kw, 'rescue')
+    exceptions = exceptions[0] if exceptions.is_a?(Array)
 
-    last_exception = exceptions.is_a?(Array) ? exceptions[-1] : exceptions
-    last_node = variable || last_exception || beging
-
+    last_node = variable || exceptions || beging
     stmts.bind(find_next_statement_start(last_node[:ec]), char_pos)
 
+    # We add an additional inner node here that ripper doesn't provide so that
+    # we have a nice place to attach inline comment. But we only need it if we
+    # have an exception or a variable that we're rescuing.
+    rescue_ex =
+      if exceptions || variable
+        {
+          type: :rescue_ex,
+          body: [exceptions, variable],
+          sl: beging[:sl],
+          sc: beging[:ec] + 1,
+          el: last_node[:el],
+          ec: last_node[:ec]
+        }
+      end
+
     Rescue.new(
       beging.merge!(
         type: :rescue,
-        body: [exceptions, variable, stmts, consequent],
-        end: lineno,
+        body: [rescue_ex, stmts, consequent],
+        el: lineno,
         ec: char_pos
       )
     )
@@ -1806,9 +1829,9 @@ class Prettier::Parser < Ripper
     {
       type: :rescue_mod,
       body: [statement, rescued],
-      start: statement[:start],
+      sl: statement[:sl],
       sc: statement[:sc],
-      end: rescued[:end],
+      el: rescued[:el],
       ec: rescued[:ec]
     }
   end
@@ -1824,7 +1847,7 @@ class Prettier::Parser < Ripper
     oper.merge!(
       type: :rest_param,
       body: [ident],
-      end: ident[:end],
+      el: ident[:el],
       ec: ident[:ec]
     )
   end
@@ -1842,7 +1865,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'return').merge!(
       type: :return,
       body: [args_add_block],
-      end: args_add_block[:end],
+      el: args_add_block[:el],
       ec: args_add_block[:ec]
     )
   end
@@ -1874,9 +1897,9 @@ class Prettier::Parser < Ripper
     {
       type: :sclass,
       body: [target, bodystmt],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -1889,12 +1912,21 @@ 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
+    attr_reader :parser
+
+    def initialize(parser, values)
+      @parser = parser
+      __setobj__(values)
+    end
+
     def bind(sc, ec)
       merge!(sc: sc, ec: ec)
 
       if self[:body][0][:type] == :void_stmt
         self[:body][0].merge!(sc: sc, ec: sc)
       end
+
+      attach_comments(sc, ec)
     end
 
     def bind_end(ec)
@@ -1903,14 +1935,30 @@ class Prettier::Parser < Ripper
 
     def <<(statement)
       if self[:body].any?
-        merge!(statement.slice(:end, :ec))
+        merge!(statement.slice(:el, :ec))
       else
-        merge!(statement.slice(:start, :end, :sc, :ec))
+        merge!(statement.slice(:sl, :el, :sc, :ec))
       end
 
       self[:body] << statement
       self
     end
+
+    private
+
+    def attach_comments(sc, ec)
+      attachable =
+        parser.comments.select do |comment|
+          comment[:type] == :@comment && !comment[:inline] &&
+            sc <= comment[:sc] && ec >= comment[:ec] &&
+            !comment[:value].include?('prettier-ignore')
+        end
+
+      return if attachable.empty?
+
+      parser.comments -= attachable
+      self[:body] = (self[:body] + attachable).sort_by! { |node| node[:sc] }
+    end
   end
 
   # stmts_new is a parser event that represents the beginning of a list of
@@ -1918,10 +1966,11 @@ class Prettier::Parser < Ripper
   # stmts_add events, which we'll append onto an array body.
   def on_stmts_new
     Stmts.new(
+      self,
       type: :stmts,
       body: [],
-      start: lineno,
-      end: lineno,
+      sl: lineno,
+      el: lineno,
       sc: char_pos,
       ec: char_pos
     )
@@ -1945,9 +1994,9 @@ class Prettier::Parser < Ripper
     {
       type: :string_concat,
       body: [left, right],
-      start: left[:start],
+      sl: left[:sl],
       sc: left[:sc],
-      end: right[:end],
+      el: right[:el],
       ec: right[:ec]
     }
   end
@@ -1961,8 +2010,8 @@ class Prettier::Parser < Ripper
     {
       type: :string,
       body: [],
-      start: lineno,
-      end: lineno,
+      sl: lineno,
+      el: lineno,
       sc: char_pos,
       ec: char_pos
     }
@@ -1973,11 +2022,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],
-      ec: piece[:ec]
-    )
+    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
@@ -1989,7 +2034,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@embvar).merge!(
       type: :string_dvar,
       body: [var_ref],
-      end: var_ref[:end],
+      el: var_ref[:el],
       ec: var_ref[:ec]
     )
   end
@@ -2007,9 +2052,9 @@ class Prettier::Parser < Ripper
     {
       type: :string_embexpr,
       body: [stmts],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -2029,9 +2074,9 @@ class Prettier::Parser < Ripper
         type: :string_literal,
         body: string[:body],
         quote: beging[:body],
-        start: beging[:start],
+        sl: beging[:sl],
         sc: beging[:sc],
-        end: ending[:end],
+        el: ending[:el],
         ec: ending[:ec]
       }
     end
@@ -2045,7 +2090,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'super').merge!(
       type: :super,
       body: [contents],
-      end: contents[:end],
+      el: contents[:el],
       ec: contents[:ec]
     )
   end
@@ -2096,7 +2141,7 @@ class Prettier::Parser < Ripper
   def on_symbols_add(symbols, word_add)
     symbols.merge!(
       body: symbols[:body] << word_add,
-      end: word_add[:end],
+      el: word_add[:el],
       ec: word_add[:ec]
     )
   end
@@ -2125,7 +2170,7 @@ class Prettier::Parser < Ripper
     const.merge(
       type: :top_const_field,
       body: [const],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc]
     )
   end
@@ -2141,7 +2186,7 @@ class Prettier::Parser < Ripper
     const.merge(
       type: :top_const_ref,
       body: [const],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc]
     )
   end
@@ -2161,7 +2206,7 @@ class Prettier::Parser < Ripper
         type: :unary,
         oper: oper,
         body: [value],
-        end: ending[:end],
+        el: ending[:el],
         ec: ending[:ec],
         paren: paren
       )
@@ -2172,7 +2217,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
 
@@ -2181,7 +2226,7 @@ class Prettier::Parser < Ripper
         type: :unary,
         oper: oper[0],
         body: [value],
-        end: value[:end],
+        el: value[:el],
         ec: value[:ec]
       )
     end
@@ -2197,7 +2242,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'undef').merge!(
       type: :undef,
       body: symbol_literals,
-      end: last[:end],
+      el: last[:el],
       ec: last[:ec]
     )
   end
@@ -2215,9 +2260,9 @@ class Prettier::Parser < Ripper
     {
       type: :unless,
       body: [predicate, stmts, consequent],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -2231,9 +2276,9 @@ class Prettier::Parser < Ripper
     {
       type: :unless_mod,
       body: [predicate, statement],
-      start: statement[:start],
+      sl: statement[:sl],
       sc: statement[:sc],
-      end: predicate[:end],
+      el: predicate[:el],
       ec: predicate[:ec]
     }
   end
@@ -2257,9 +2302,9 @@ class Prettier::Parser < Ripper
     {
       type: :until,
       body: [predicate, stmts],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -2273,9 +2318,9 @@ class Prettier::Parser < Ripper
     {
       type: :until_mod,
       body: [predicate, statement],
-      start: statement[:start],
+      sl: statement[:sl],
       sc: statement[:sc],
-      end: predicate[:end],
+      el: predicate[:el],
       ec: predicate[:ec]
     }
   end
@@ -2293,9 +2338,9 @@ class Prettier::Parser < Ripper
     {
       type: :var_alias,
       body: [left, right],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -2348,7 +2393,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, sc: char_pos, ec: 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.
@@ -2364,9 +2409,9 @@ class Prettier::Parser < Ripper
     {
       type: :when,
       body: [predicate, stmts, consequent],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -2390,9 +2435,9 @@ class Prettier::Parser < Ripper
     {
       type: :while,
       body: [predicate, stmts],
-      start: beging[:start],
+      sl: beging[:sl],
       sc: beging[:sc],
-      end: ending[:end],
+      el: ending[:el],
       ec: ending[:ec]
     }
   end
@@ -2406,9 +2451,9 @@ class Prettier::Parser < Ripper
     {
       type: :while_mod,
       body: [predicate, statement],
-      start: statement[:start],
+      sl: statement[:sl],
       sc: statement[:sc],
-      end: predicate[:end],
+      el: predicate[:el],
       ec: predicate[:ec]
     }
   end
@@ -2439,7 +2484,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], ec: piece[:ec])
+      word.merge!(body: word[:body] << piece, el: piece[:el], ec: piece[:ec])
     end
   end
 
@@ -2458,7 +2503,7 @@ class Prettier::Parser < Ripper
   def on_words_add(words, word_add)
     words.merge!(
       body: words[:body] << word_add,
-      end: word_add[:end],
+      el: word_add[:el],
       ec: word_add[:ec]
     )
   end
@@ -2492,7 +2537,7 @@ class Prettier::Parser < Ripper
   def on_xstring_add(xstring, piece)
     xstring.merge!(
       body: xstring[:body] << piece,
-      end: piece[:end],
+      el: piece[:el],
       ec: piece[:ec]
     )
   end
@@ -2518,7 +2563,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], ec: ending[:ec])
+      xstring.merge!(type: :xstring_literal, el: ending[:el], ec: ending[:ec])
     end
   end
 
@@ -2529,7 +2574,7 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'yield').merge!(
       type: :yield,
       body: [args_add_block],
-      end: args_add_block[:end],
+      el: args_add_block[:el],
       ec: args_add_block[:ec]
     )
   end
@@ -2550,24 +2595,3 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'super').merge!(type: :zsuper)
   end
 end
-
-# If this is the main file we're executing, then most likely this is being
-# executed from the parser.js spawn. In that case, read the ruby source from
-# stdin and report back the AST over stdout.
-
-if $0 == __FILE__
-  builder = Prettier::Parser.new($stdin.read)
-  response = builder.parse
-
-  if !response || builder.error?
-    warn(
-      '@prettier/plugin-ruby encountered an error when attempting to parse ' \
-        'the ruby source. This usually means there was a syntax error in the ' \
-        'file in question. You can verify by running `ruby -i [path/to/file]`.'
-    )
-
-    exit 1
-  end
-
-  puts JSON.fast_generate(response)
-end