prettier 1.2.4 → 1.5.1

data/src/rbs/printer.js

@@ -0,0 +1,605 @@
+const {
+  concat,
+  group,
+  hardline,
+  indent,
+  makeString,
+  join,
+  line,
+  softline
+} = require("../prettier");
+
+// For some lists of entities in the AST, the parser returns them as an unsorted
+// object (presumably because Ruby hashes have implicit ordering). We do not
+// have that in JavaScript, so here we sort each object by its position in the
+// source string.
+function getSortedKeys(object) {
+  return Object.keys(object).sort(
+    (left, right) =>
+      object[left].type.location.start_pos -
+      object[right].type.location.start_pos
+  );
+}
+
+// In some cases, we want to just defer to whatever was in the source.
+function getSource(node, opts) {
+  return opts.originalText.slice(
+    node.location.start_pos,
+    node.location.end_pos
+  );
+}
+
+// This is the generic node print function, used to convert any node in the AST
+// into its equivalent Doc representation.
+function printNode(path, opts, print) {
+  const node = path.getValue();
+  let doc = null;
+
+  if (node.declarations) {
+    return printRoot();
+  }
+
+  /* istanbul ignore else */
+  if (node.declaration) {
+    switch (node.declaration) {
+      case "alias":
+        doc = printTypeAlias();
+        break;
+      case "class":
+        doc = printClass();
+        break;
+      case "constant":
+      case "global":
+        doc = printConstant();
+        break;
+      case "interface":
+        doc = printInterface();
+        break;
+      case "module":
+        doc = printModule();
+        break;
+      /* istanbul ignore next */
+      default:
+        throw new Error(`unknown declaration: ${node.declaration}`);
+    }
+  } else if (node.member) {
+    switch (node.member) {
+      case "alias":
+        doc = printAlias();
+        break;
+      case "attr_accessor":
+      case "attr_reader":
+      case "attr_writer":
+        doc = printAttr();
+        break;
+      case "class_variable":
+      case "instance_variable":
+        doc = printVariable();
+        break;
+      case "class_instance_variable":
+        doc = concat(["self.", printVariable()]);
+        break;
+      case "include":
+      case "extend":
+      case "prepend":
+        doc = printMixin();
+        break;
+      case "public":
+      case "private":
+        doc = node.member;
+        break;
+      case "method_definition":
+        doc = printMethodDefinition();
+        break;
+      /* istanbul ignore next */
+      default:
+        throw new Error(`unknown member: ${node.member}`);
+    }
+  } else {
+    const ast = JSON.stringify(node, null, 2);
+    throw new Error(`Unsupported node encountered:\n${ast}`);
+  }
+
+  // Certain nodes can't have annotations at all
+  if (node.annotations && node.annotations.length > 0) {
+    doc = concat([printAnnotations(), hardline, doc]);
+  }
+
+  if (node.comment) {
+    doc = concat([printComment(), hardline, doc]);
+  }
+
+  return doc;
+
+  // Prints out a string in the source, which looks like:
+  // 'foo'
+  function printString(node) {
+    // We're going to go straight to the source here, as if we don't then we're
+    // going to end up with the result of String#inspect, which does weird
+    // things to escape sequences.
+    const value = getSource(node, opts);
+
+    // Get the quote that was used in the source and the quote that we want to
+    // be using.
+    const originalQuote = value[0];
+    const preferredQuote = opts.rubySingleQuote ? "'" : '"';
+
+    // Determine if we're allowed to change the quote based on whether or not
+    // there is an escape sequence in the source string.
+    const quote = node.literal.includes("\\") ? originalQuote : preferredQuote;
+
+    return makeString(value.slice(1, -1), quote, false);
+  }
+
+  // Certain nodes are names with optional arguments attached, as in Array[A].
+  // We handle all of that printing centralized here.
+  function printNameAndArgs(path) {
+    const node = path.getValue();
+
+    if (node.args.length === 0) {
+      return node.name;
+    }
+
+    return group(
+      concat([node.name, "[", join(", ", path.map(printType, "args")), "]"])
+    );
+  }
+
+  // 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) {
+    const node = path.getValue();
+
+    switch (node.class) {
+      case "literal":
+        if (node.literal[0] === '"') {
+          return printString(node);
+        }
+        return node.literal;
+      case "optional":
+        return concat([path.call(printType, "type"), "?"]);
+      case "tuple":
+        // If we don't have any sub types, we explicitly need the space in between
+        // the brackets to not confuse the parser.
+        if (node.types.length === 0) {
+          return "[ ]";
+        }
+
+        return group(
+          concat(["[", join(", ", path.map(printType, "types")), "]"])
+        );
+      case "union": {
+        const doc = group(
+          join(concat([line, "| "]), path.map(printType, "types"))
+        );
+
+        const parentType = path.getParentNode().class;
+        return parentType === "intersection" ? concat(["(", doc, ")"]) : doc;
+      }
+      case "intersection":
+        return group(join(concat([line, "& "]), path.map(printType, "types")));
+      case "class_singleton":
+        return concat(["singleton(", node.name, ")"]);
+      case "proc":
+        return concat(["^", printMethodSignature(path)]);
+      case "record": {
+        const parts = [];
+
+        getSortedKeys(node.fields).forEach((field) => {
+          const fieldParts = [];
+
+          if (node.fields[field].joiner === "rocket") {
+            fieldParts.push(`${field} => `);
+          } else {
+            fieldParts.push(`${field}: `);
+          }
+
+          fieldParts.push(path.call(printType, "fields", field, "type"));
+          parts.push(concat(fieldParts));
+        });
+
+        return group(
+          concat([
+            "{",
+            indent(concat([line, join(concat([",", line]), parts)])),
+            line,
+            "}"
+          ])
+        );
+      }
+      case "class_instance":
+      case "interface":
+        return printNameAndArgs(path);
+      case "alias":
+      case "variable":
+        return node.name;
+      case "bool":
+      case "bot":
+      case "class":
+      case "instance":
+      case "nil":
+      case "self":
+      case "top":
+      case "untyped":
+      case "void":
+        return node.class;
+      /* istanbul ignore next */
+      default:
+        throw new Error(`unknown type: ${node.class}`);
+    }
+  }
+
+  // Prints out the root of the tree, which includes zero or more declarations.
+  function printRoot() {
+    return concat([
+      join(concat([hardline, hardline]), path.map(print, "declarations")),
+      hardline
+    ]);
+  }
+
+  // Prints out the members of a class, module, or interface.
+  function printMembers() {
+    let lastLine = null;
+    const docs = [];
+
+    path.each((memberPath) => {
+      const memberNode = memberPath.getValue();
+
+      if (lastLine !== null && memberNode.location.start.line - lastLine >= 2) {
+        docs.push(concat([hardline, hardline]));
+      } else {
+        docs.push(hardline);
+      }
+
+      docs.push(print(memberPath));
+      lastLine = memberNode.location.end.line;
+    }, "members");
+
+    return concat(docs);
+  }
+
+  // Prints out a type alias, which is a declaration that looks like:
+  // type foo = String
+  function printTypeAlias() {
+    return group(
+      concat([
+        "type ",
+        node.name,
+        " =",
+        indent(group(concat([line, path.call(printType, "type")])))
+      ])
+    );
+  }
+
+  // Prints out the name of a class, interface, or module declaration.
+  // Additionally loops through each type parameter if there are any and print
+  // them out joined by commas. Checks for validation and variance.
+  function printNameAndTypeParams() {
+    if (node.type_params.params.length === 0) {
+      return node.name;
+    }
+
+    const docs = path.map(
+      (paramPath) => {
+        const node = paramPath.getValue();
+        const parts = [];
+
+        if (node.skip_validation) {
+          parts.push("unchecked");
+        }
+
+        if (node.variance === "covariant") {
+          parts.push("out");
+        } else if (node.variance === "contravariant") {
+          parts.push("in");
+        }
+
+        return join(" ", parts.concat(node.name));
+      },
+      "type_params",
+      "params"
+    );
+
+    return concat([node.name, "[", join(", ", docs), "]"]);
+  }
+
+  // Prints out a class declarations, which looks like:
+  // class Foo end
+  function printClass() {
+    const parts = ["class ", printNameAndTypeParams()];
+
+    if (node.super_class) {
+      parts.push(" < ", path.call(printNameAndArgs, "super_class"));
+    }
+
+    parts.push(indent(printMembers()), hardline, "end");
+
+    return group(concat(parts));
+  }
+
+  // Prints out a constant or a global declaration, which looks like:
+  // Foo: String
+  // $foo: String
+  function printConstant() {
+    return group(concat([node.name, ": ", path.call(printType, "type")]));
+  }
+
+  // Prints out an interface declaration, which looks like:
+  // interface _Foo end
+  function printInterface() {
+    return group(
+      concat([
+        "interface ",
+        printNameAndTypeParams(),
+        indent(printMembers()),
+        hardline,
+        "end"
+      ])
+    );
+  }
+
+  // Prints out a module declaration, which looks like:
+  // module Foo end
+  function printModule() {
+    const parts = ["module ", printNameAndTypeParams()];
+
+    if (node.self_types.length > 0) {
+      parts.push(" : ", join(", ", path.map(printNameAndArgs, "self_types")));
+    }
+
+    parts.push(indent(printMembers()), hardline, "end");
+
+    return group(concat(parts));
+  }
+
+  // Prints out an alias within a declaration, which looks like:
+  // alias foo bar
+  // alias self.foo self.bar
+  function printAlias() {
+    if (node.kind === "singleton") {
+      return concat(["alias self.", node.new_name, " self.", node.old_name]);
+    }
+
+    return concat(["alias ", node.new_name, " ", node.old_name]);
+  }
+
+  // Prints out an attr_* meta method, which looks like:
+  // attr_accessor foo
+  // attr_reader self.foo()
+  // attr_writer self.foo(@bar): String
+  function printAttr() {
+    const parts = [node.member, " "];
+
+    if (node.kind === "singleton") {
+      parts.push("self.");
+    }
+
+    parts.push(node.name);
+
+    if (node.ivar_name === false) {
+      parts.push("()");
+    } else if (node.ivar_name) {
+      parts.push("(", node.ivar_name, ")");
+    }
+
+    parts.push(": ", path.call(printType, "type"));
+
+    return group(concat(parts));
+  }
+
+  // Prints out a variable member, which looks like:
+  // @foo: String
+  // self.@foo: String
+  // @@foo: String
+  function printVariable() {
+    return group(concat([node.name, ": ", path.call(printType, "type")]));
+  }
+
+  // Prints out a mixin, which looks like:
+  // include Foo
+  // prepend Foo
+  // extend Foo
+  function printMixin() {
+    return group(concat([node.member, " ", printNameAndArgs(path)]));
+  }
+
+  // Returns an array of printed parameters so that the calling function can
+  // join them together in whatever way.
+  function printMethodParams(path) {
+    const node = path.getValue();
+    let parts = [];
+
+    // required positionals, as in (A)
+    parts = parts.concat(path.map(printMethodParam, "required_positionals"));
+
+    // optional positionals, as in (?A)
+    parts = parts.concat(
+      path.map(
+        (paramPath) => concat(["?", printMethodParam(paramPath)]),
+        "optional_positionals"
+      )
+    );
+
+    // rest positional, as in (*A)
+    if (node.rest_positionals) {
+      parts.push(
+        concat(["*", path.call(printMethodParam, "rest_positionals")])
+      );
+    }
+
+    // trailing positionals are required positionals after a rest
+    parts = parts.concat(path.map(printMethodParam, "trailing_positionals"));
+
+    // required keywords, as in (a: A)
+    getSortedKeys(node.required_keywords).forEach((name) => {
+      parts.push(
+        concat([
+          name,
+          ": ",
+          path.call(printMethodParam, "required_keywords", name)
+        ])
+      );
+    });
+
+    // optional keywords, as in (?a: A)
+    getSortedKeys(node.optional_keywords).forEach((name) => {
+      parts.push(
+        concat([
+          "?",
+          name,
+          ": ",
+          path.call(printMethodParam, "optional_keywords", name)
+        ])
+      );
+    });
+
+    // rest keyword, as in (**A)
+    if (node.rest_keywords) {
+      parts.push(concat(["**", path.call(printMethodParam, "rest_keywords")]));
+    }
+
+    return parts;
+
+    // Prints out a method parameter at a given path. Handles printing out the
+    // name if there is one (and whether or not it's escaped).
+    function printMethodParam(path) {
+      const node = path.getValue();
+      const parts = [path.call(printType, "type")];
+
+      if (node.name) {
+        parts.push(" ");
+
+        if (node.escaped) {
+          parts.push("`", node.name, "`");
+        } else {
+          parts.push(node.name);
+        }
+      }
+
+      return concat(parts);
+    }
+  }
+
+  // Prints out a specific method signature, which looks like:
+  // (T t) -> void
+  function printMethodSignature(path) {
+    const node = path.getValue();
+    const parts = [];
+
+    // We won't have a type_params key if we're printing a block
+    if (node.type_params && node.type_params.length > 0) {
+      parts.push("[", join(", ", node.type_params), "] ");
+    }
+
+    let params = path.call(printMethodParams, "type");
+
+    if (params.length > 0) {
+      parts.push(
+        "(",
+        indent(concat([softline, join(concat([",", line]), params)])),
+        softline,
+        ") "
+      );
+    }
+
+    if (node.block) {
+      if (!node.block.required) {
+        parts.push("?");
+      }
+
+      parts.push(
+        "{",
+        indent(concat([line, path.call(printMethodSignature, "block")])),
+        line,
+        "} "
+      );
+    }
+
+    parts.push("-> ", path.call(printType, "type", "return_type"));
+
+    return group(concat(parts));
+  }
+
+  // Prints out a method definition, which looks like:
+  // def t: (T t) -> void
+  function printMethodDefinition() {
+    let typeDocs = path.map(printMethodSignature, "types");
+
+    if (node.overload) {
+      typeDocs.push("...");
+    }
+
+    if (typeDocs.length === 1) {
+      typeDocs = concat([" ", typeDocs[0]]);
+    } else {
+      typeDocs = indent(
+        group(concat([line, join(concat([line, "| "]), typeDocs)]))
+      );
+    }
+
+    const parts = ["def "];
+
+    if (node.kind === "singleton") {
+      parts.push("self.");
+    } else if (node.kind === "singleton_instance") {
+      parts.push("self?.");
+    }
+
+    const escaped = isMethodNameEscaped();
+    parts.push(escaped ? `\`${node.name}\`` : node.name, ":", typeDocs);
+
+    return group(concat(parts));
+
+    // Determine if a method name is escaped in the original source.
+    function isMethodNameEscaped() {
+      const pos = node.location.start_pos + 4;
+      const name = opts.originalText.slice(pos, pos + 2).trimStart();
+
+      return name[0] === "`" && name[1] !== ":";
+    }
+  }
+
+  // An annotation can be attached to most kinds of nodes, and should be printed
+  // using %a{}.
+  function printAnnotations() {
+    return join(hardline, path.map(printAnnotation, "annotations"));
+
+    function printAnnotation(path) {
+      const node = path.getValue();
+
+      // If there are already braces inside the annotation, then we're just
+      // going to print out the original string to avoid having to escape
+      // anything.
+      if (/[{}]/.test(node.string)) {
+        return getSource(node, opts);
+      }
+
+      return concat(["%a{", node.string, "}"]);
+    }
+  }
+
+  // Comments come in as one whole string, so here we split it up into multiple
+  // lines and then prefix it with the pound sign.
+  function printComment() {
+    const lines = node.comment.string.slice(0, -1).split("\n");
+
+    return join(
+      hardline,
+      lines.map((segment) => `# ${segment}`)
+    );
+  }
+}
+
+// This is an escape-hatch to ignore nodes in the tree. If you have a comment
+// that includes this pattern, then the entire node will be ignored and just the
+// original source will be printed out.
+function hasPrettierIgnore(path) {
+  const node = path.getValue();
+
+  return node.comment && node.comment.string.includes("prettier-ignore");
+}
+
+module.exports = {
+  print: printNode,
+  hasPrettierIgnore
+};