prettier 1.5.0 → 1.5.5

data/src/rbs/parser.rb

@@ -86,9 +86,13 @@ end
 module Prettier
   class RBSParser
     def self.parse(text)
-      { declarations: RBS::Parser.parse_signature(text) }
-    rescue StandardError
-      false
+      {
+        declarations: RBS::Parser.parse_signature(text),
+        location: {
+          start_pos: 0,
+          end_pos: text.length
+        }
+      }
     end
   end
 end

data/src/rbs/printer.js

@@ -147,7 +147,7 @@ function printNode(path, opts, print) {
 
   // This is the big function that prints out any individual type, which can
   // look like all kinds of things, listed in the case statement below.
-  function printType(path) {
+  function printType(path, { forceUnionParens = false } = {}) {
     const node = path.getValue();
 
     switch (node.class) {
@@ -173,8 +173,11 @@ function printNode(path, opts, print) {
           join(concat([line, "| "]), path.map(printType, "types"))
         );
 
-        const parentType = path.getParentNode().class;
-        return parentType === "intersection" ? concat(["(", doc, ")"]) : doc;
+        if (forceUnionParens || path.getParentNode().class === "intersection") {
+          return concat(["(", doc, ")"]);
+        }
+
+        return doc;
       }
       case "intersection":
         return group(join(concat([line, "& "]), path.map(printType, "types")));
@@ -515,7 +518,14 @@ function printNode(path, opts, print) {
       );
     }
 
-    parts.push("-> ", path.call(printType, "type", "return_type"));
+    parts.push(
+      "-> ",
+      path.call(
+        (typePath) => printType(typePath, { forceUnionParens: true }),
+        "type",
+        "return_type"
+      )
+    );
 
     return group(concat(parts));
   }

data/src/ruby/embed.js

@@ -8,7 +8,7 @@ const {
   stripTrailingHardline
 } = require("../prettier");
 
-const { literalLineNoBreak } = require("../utils");
+const { literallineWithoutBreakParent } = require("../utils");
 
 const parsers = {
   css: "css",
@@ -30,7 +30,7 @@ function replaceNewlines(doc) {
       ? concat(
           currentDoc
             .split(/(\n)/g)
-            .map((v, i) => (i % 2 === 0 ? v : literalLineNoBreak))
+            .map((v, i) => (i % 2 === 0 ? v : literallineWithoutBreakParent))
         )
       : currentDoc
   );
@@ -106,7 +106,7 @@ function embed(path, print, textToDoc, _opts) {
 
   // Pass that content into the embedded parser. Get back the doc node.
   const formatted = concat([
-    literalLineNoBreak,
+    literallineWithoutBreakParent,
     replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
   ]);
 
@@ -119,7 +119,7 @@ function embed(path, print, textToDoc, _opts) {
         group(
           concat([
             indent(markAsRoot(formatted)),
-            literalLineNoBreak,
+            literallineWithoutBreakParent,
             ending.trim()
           ])
         )
@@ -132,7 +132,9 @@ function embed(path, print, textToDoc, _opts) {
   return markAsRoot(
     concat([
       path.call(print, "beging"),
-      lineSuffix(group(concat([formatted, literalLineNoBreak, ending.trim()])))
+      lineSuffix(
+        group(concat([formatted, literallineWithoutBreakParent, ending.trim()]))
+      )
     ])
   );
 }

data/src/ruby/nodes/args.js

@@ -58,7 +58,7 @@ function printArgParen(path, opts, print) {
         concat([
           softline,
           join(concat([",", line]), path.call(print, "body", 0)),
-          getTrailingComma(opts) && getArgParenTrailingComma(argsNode)
+          getTrailingComma(opts) ? getArgParenTrailingComma(argsNode) : ""
         ])
       ),
       softline,
@@ -106,25 +106,73 @@ function printArgs(path, { rubyToProc }, print) {
   return args;
 }
 
+function printArgsAddBlock(path, opts, print) {
+  const node = path.getValue();
+  const parts = path.call(print, "body", 0);
+
+  if (node.body[1]) {
+    let blockDoc = path.call(print, "body", 1);
+
+    if (node.body[1].comments) {
+      // If we have a method call like:
+      //
+      //     foo(
+      //       # comment
+      //       &block
+      //     )
+      //
+      // then we need to make sure we don't accidentally prepend the operator
+      // before the comment.
+      blockDoc.parts[2] = concat(["&", blockDoc.parts[2]]);
+    } else {
+      // If we don't have any comments, we can just prepend the operator
+      blockDoc = concat(["&", blockDoc]);
+    }
+
+    parts.push(blockDoc);
+  }
+
+  return parts;
+}
+
+function printArgsAddStar(path, opts, print) {
+  const node = path.getValue();
+  const docs = path.map(print, "body");
+
+  if (node.body[1].comments) {
+    // If we have an array like:
+    //
+    //     [
+    //       # comment
+    //       *values
+    //     ]
+    //
+    // or if we have an array like:
+    //
+    //     [
+    //       *values # comment
+    //     ]
+    //
+    // then we need to make sure we don't accidentally prepend the operator
+    // before the comment.
+    const index = node.body[1].comments.filter(({ leading }) => leading).length;
+    docs[1].parts[index] = concat(["*", docs[1].parts[index]]);
+  } else {
+    // If we don't have any comments, we can just prepend the operator
+    docs[1] = concat(["*", docs[1]]);
+  }
+
+  return docs[0].concat(docs[1]).concat(docs.slice(2));
+}
+
+function printBlockArg(path, opts, print) {
+  return concat(["&", path.call(print, "body", 0)]);
+}
+
 module.exports = {
   arg_paren: printArgParen,
   args: printArgs,
-  args_add_block: (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
-
-    if (path.getValue().body[1]) {
-      parts.push(concat(["&", path.call(print, "body", 1)]));
-    }
-
-    return parts;
-  },
-  args_add_star: (path, opts, print) => {
-    const printed = path.map(print, "body");
-    const parts = printed[0]
-      .concat([concat(["*", printed[1]])])
-      .concat(printed.slice(2));
-
-    return parts;
-  },
-  blockarg: (path, opts, print) => concat(["&", path.call(print, "body", 0)])
+  args_add_block: printArgsAddBlock,
+  args_add_star: printArgsAddStar,
+  blockarg: printBlockArg
 };

data/src/ruby/nodes/arrays.js

@@ -63,33 +63,30 @@ function isSymbolArray(args) {
 // Prints out a word that is a part of a special array literal that accepts
 // interpolation. The body is an array of either plain strings or interpolated
 // expressions.
-function printSpecialArrayWord(path, opts, print) {
+function printArrayLiteralWord(path, opts, print) {
   return concat(path.map(print, "body"));
 }
 
 // Prints out a special array literal. Accepts the parts of the array literal as
 // an argument, where the first element of the parts array is a string that
 // contains the special start.
-function printSpecialArrayParts(parts) {
+function printArrayLiteral(start, parts) {
   return group(
     concat([
-      parts[0],
+      start,
       "[",
-      indent(concat([softline, join(line, parts.slice(1))])),
+      indent(concat([softline, join(line, parts)])),
       concat([softline, "]"])
     ])
   );
 }
 
-// Generates a print function with an embedded special start character for the
-// specific type of array literal that we're dealing with. The print function
-// returns an array as it expects to eventually be handed off to
-// printSpecialArrayParts.
-function printSpecialArray(start) {
-  return function printSpecialArrayWithStart(path, opts, print) {
-    return [start].concat(path.map(print, "body"));
-  };
-}
+const arrayLiteralStarts = {
+  qsymbols: "%i",
+  qwords: "%w",
+  symbols: "%I",
+  words: "%W"
+};
 
 // An array node is any literal array in Ruby. This includes all of the special
 // array literals as well as regular arrays. If it is a special array literal
@@ -105,30 +102,40 @@ function printArray(path, opts, print) {
     return printEmptyCollection(path, opts, "[", "]");
   }
 
-  // If we have an array that contains only simple string literals with no
-  // spaces or interpolation, then we're going to print a %w array.
-  if (opts.rubyArrayLiteral && isStringArray(args)) {
-    const printString = (stringPath) => stringPath.call(print, "body", 0);
-    const parts = path.map(printString, "body", 0, "body");
+  if (opts.rubyArrayLiteral) {
+    // If we have an array that contains only simple string literals with no
+    // spaces or interpolation, then we're going to print a %w array.
+    if (isStringArray(args)) {
+      const printString = (stringPath) => stringPath.call(print, "body", 0);
+      const parts = path.map(printString, "body", 0, "body");
 
-    return printSpecialArrayParts(["%w"].concat(parts));
-  }
+      return printArrayLiteral("%w", parts);
+    }
 
-  // If we have an array that contains only simple symbol literals with no
-  // interpolation, then we're going to print a %i array.
-  if (opts.rubyArrayLiteral && isSymbolArray(args)) {
-    const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
-    const parts = path.map(printSymbol, "body", 0, "body");
+    // If we have an array that contains only simple symbol literals with no
+    // interpolation, then we're going to print a %i array.
+    if (isSymbolArray(args)) {
+      const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
+      const parts = path.map(printSymbol, "body", 0, "body");
 
-    return printSpecialArrayParts(["%i"].concat(parts));
+      return printArrayLiteral("%i", parts);
+    }
   }
 
   // If we don't have a regular args node at this point then we have a special
   // array literal. In that case we're going to print out the body (which will
   // return to us an array with the first one being the start of the array) and
-  // send that over to the printSpecialArrayParts function.
+  // send that over to the printArrayLiteral function.
   if (!["args", "args_add_star"].includes(args.type)) {
-    return printSpecialArrayParts(path.call(print, "body", 0));
+    return path.call(
+      (arrayPath) =>
+        printArrayLiteral(
+          arrayLiteralStarts[arrayPath.getValue().type],
+          arrayPath.map(print, "body")
+        ),
+      "body",
+      0
+    );
   }
 
   // Here we have a normal array of any type of object with no special literal
@@ -151,9 +158,5 @@ function printArray(path, opts, print) {
 
 module.exports = {
   array: printArray,
-  qsymbols: printSpecialArray("%i"),
-  qwords: printSpecialArray("%w"),
-  symbols: printSpecialArray("%I"),
-  word: printSpecialArrayWord,
-  words: printSpecialArray("%W")
+  word: printArrayLiteralWord
 };

data/src/ruby/nodes/commands.js

@@ -73,7 +73,7 @@ function printCommand(path, opts, print) {
   } else if (hasDef(path.getValue())) {
     breakArgs = joinedArgs;
   } else {
-    breakArgs = align(command.length + 1, joinedArgs);
+    breakArgs = align(docLength(command) + 1, joinedArgs);
   }
 
   return group(

data/src/ruby/nodes/heredocs.js

@@ -1,5 +1,5 @@
 const { concat, group, lineSuffix, join } = require("../../prettier");
-const { literalLineNoBreak } = require("../../utils");
+const { literallineWithoutBreakParent } = require("../../utils");
 
 function printHeredoc(path, opts, print) {
   const { body, ending } = path.getValue();
@@ -11,7 +11,7 @@ function printHeredoc(path, opts, print) {
     }
 
     // In this case, the part of the string is just regular string content
-    return join(literalLineNoBreak, part.body.split("\n"));
+    return join(literallineWithoutBreakParent, part.body.split("\n"));
   });
 
   // We use a literalline break because matching indentation is required
@@ -23,7 +23,9 @@ function printHeredoc(path, opts, print) {
     concat([
       path.call(print, "beging"),
       lineSuffix(
-        group(concat([literalLineNoBreak].concat(parts).concat(ending)))
+        group(
+          concat([literallineWithoutBreakParent].concat(parts).concat(ending))
+        )
       )
     ])
   );

data/src/ruby/parser.js

@@ -4,8 +4,8 @@ const parseSync = require("../parser/parseSync");
 // 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) {
-  return parseSync("ruby", text);
+function parse(text, _parsers, opts) {
+  return parseSync("ruby", text, opts);
 }
 
 const pragmaPattern = /#\s*@(prettier|format)/;

data/src/ruby/parser.rb

@@ -21,7 +21,40 @@ module Prettier
 end
 
 class Prettier::Parser < Ripper
-  attr_reader :source, :lines, :scanner_events, :line_counts
+  # Represents a line in the source. If this class is being used, it means that
+  # every character in the string is 1 byte in length, so we can just return the
+  # start of the line + the index.
+  class SingleByteString
+    def initialize(start)
+      @start = start
+    end
+
+    def [](byteindex)
+      @start + byteindex
+    end
+  end
+
+  # Represents a line in the source. If this class is being used, it means that
+  # there are characters in the string that are multi-byte, so we will build up
+  # an array of indices, such that array[byteindex] will be equal to the index
+  # of the character within the string.
+  class MultiByteString
+    def initialize(start, line)
+      @indices = []
+
+      line
+        .each_char
+        .with_index(start) do |char, index|
+          char.bytesize.times { @indices << index }
+        end
+    end
+
+    def [](byteindex)
+      @indices[byteindex]
+    end
+  end
+
+  attr_reader :source, :lines, :scanner_events
 
   # This is an attr_accessor so Stmts objects can grab comments out of this
   # array and attach them to themselves.
@@ -40,9 +73,23 @@ class Prettier::Parser < Ripper
     @heredocs = []
 
     @scanner_events = []
-    @line_counts = [0]
+    @line_counts = []
+
+    # Here we're going to build up a list of SingleByteString or MultiByteString
+    # objects. They're each going to represent a string in the source. They are
+    # used by the `char_pos` method to determine where we are in the source
+    # string.
+    last_index = 0
 
-    @source.lines.each { |line| @line_counts << @line_counts.last + line.size }
+    @source.lines.each do |line|
+      if line.size == line.bytesize
+        @line_counts << SingleByteString.new(last_index)
+      else
+        @line_counts << MultiByteString.new(last_index, line)
+      end
+
+      last_index += line.size
+    end
   end
 
   def self.parse(source)
@@ -60,7 +107,7 @@ class Prettier::Parser < Ripper
   # this line, then we add the number of columns into this line that we've gone
   # through.
   def char_pos
-    line_counts[lineno - 1] + column
+    @line_counts[lineno - 1][column]
   end
 
   # As we build up a list of scanner events, we'll periodically need to go
@@ -518,6 +565,12 @@ class Prettier::Parser < Ripper
   # binary is a parser event that represents a binary operation between two
   # values.
   def on_binary(left, oper, right)
+    # On most Ruby implementations, oper is a Symbol that represents that
+    # operation being performed. For instance in the example `1 < 2`, the `oper`
+    # object would be `:<`. However, on JRuby, it's an `@op` node, so here we're
+    # going to explicitly convert it into the same normalized form.
+    oper = scanner_events.delete(oper)[:body] unless oper.is_a?(Symbol)
+
     {
       type: :binary,
       body: [left, oper, right],
@@ -609,7 +662,7 @@ class Prettier::Parser < Ripper
       body: [block_var, stmts],
       sl: beging[:sl],
       sc: beging[:sc],
-      el: ending[:el],
+      el: [ending[:el], stmts[:el]].max,
       ec: ending[:ec]
     }
   end
@@ -662,7 +715,7 @@ class Prettier::Parser < Ripper
       body: [receiver, oper, sending],
       sl: receiver[:sl],
       sc: receiver[:sc],
-      el: ending[:el],
+      el: [ending[:el], receiver[:el]].max,
       ec: ending[:ec]
     }
   end
@@ -1676,6 +1729,28 @@ class Prettier::Parser < Ripper
     )
   end
 
+  # A special parser error so that we can get nice syntax displays on the error
+  # message when prettier prints out the results.
+  class ParserError < StandardError
+    attr_reader :lineno, :column
+
+    def initialize(error, lineno, column)
+      super(error)
+      @lineno = lineno
+      @column = column
+    end
+  end
+
+  # If we encounter a parse error, just immediately bail out so that our runner
+  # can catch it.
+  def on_parse_error(error, *)
+    raise ParserError.new(error, lineno, column)
+  end
+  alias on_alias_error on_parse_error
+  alias on_assign_error on_parse_error
+  alias on_class_name_error on_parse_error
+  alias on_param_error on_parse_error
+
   # The program node is the very top of the AST. Here we'll attach all of
   # the comments that we've gathered up over the course of parsing the
   # source string. We'll also attach on the __END__ content if there was