prettier 1.2.1 → 1.3.0

data/src/haml/parser.js

@@ -0,0 +1,33 @@
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+const parser = path.join(__dirname, "./parser.rb");
+
+const parse = (text, _parsers, _opts) => {
+  const child = spawnSync("ruby", [parser], { input: text });
+
+  const error = child.stderr.toString();
+  if (error) {
+    throw new Error(error);
+  }
+
+  const response = child.stdout.toString();
+  return JSON.parse(response);
+};
+
+const pragmaPattern = /^\s*-#\s*@(prettier|format)/;
+const hasPragma = (text) => pragmaPattern.test(text);
+
+// These functions are just placeholders until we can actually perform this
+// properly. The functions are necessary otherwise the format with cursor
+// functions break.
+const locStart = (_node) => 0;
+const locEnd = (_node) => 0;
+
+module.exports = {
+  parse,
+  astFormat: "haml",
+  hasPragma,
+  locStart,
+  locEnd
+};

data/src/haml/parser.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'bundler/setup' if ENV['CI']
+require 'haml'
+require 'json'
+require 'ripper'
+
+class Haml::Parser::ParseNode
+  class DeepAttributeParser
+    def parse(string)
+      Haml::AttributeParser.available? ? parse_value(string) : string
+    end
+
+    private
+
+    def literal(string, level)
+      level == 0 ? string : "&#{string}"
+    end
+
+    def parse_value(string, level = 0)
+      response = Ripper.sexp(string)
+      return literal(string, level) unless response
+
+      case response[1][0][0]
+      when :hash
+        hash = Haml::AttributeParser.parse(string)
+
+        if hash
+          # Explicitly not using Enumerable#to_h here to support Ruby 2.5
+          hash.each_with_object({}) do |(key, value), response|
+            response[key] = parse_value(value, level + 1)
+          end
+        else
+          literal(string, level)
+        end
+      when :string_literal
+        string[1...-1]
+      else
+        literal(string, level)
+      end
+    end
+  end
+
+  ESCAPE = /Haml::Helpers.html_escape\(\((.+)\)\)/.freeze
+
+  # If a node comes in as the plain type but starts with one of the special
+  # characters that haml parses, then we need to escape it with a \ when
+  # printing. So here we make a regexp pattern to check if the node needs to be
+  # escaped.
+  special_chars =
+    Haml::Parser::SPECIAL_CHARACTERS.map { |char| Regexp.escape(char) }
+
+  SPECIAL_START = /\A(?:#{special_chars.join('|')})/
+
+  def as_json
+    case type
+    when :comment, :doctype, :silent_script
+      to_h.tap do |json|
+        json.delete(:parent)
+        json[:children] = children.map(&:as_json)
+      end
+    when :filter, :haml_comment
+      to_h.tap { |json| json.delete(:parent) }
+    when :plain
+      to_h.tap do |json|
+        json.delete(:parent)
+        json[:children] = children.map(&:as_json)
+
+        text = json[:value][:text]
+        json[:value][:text] = "\\#{text}" if text.match?(SPECIAL_START)
+      end
+    when :root
+      to_h.tap { |json| json[:children] = children.map(&:as_json) }
+    when :script
+      to_h.tap do |json|
+        json.delete(:parent)
+        json[:children] = children.map(&:as_json)
+
+        if json[:value][:text].match?(ESCAPE)
+          json[:value][:text].gsub!(ESCAPE) { $1 }
+          json[:value].merge!(escape_html: 'escape_html', interpolate: true)
+        end
+      end
+    when :tag
+      to_h.tap do |json|
+        json.delete(:parent)
+
+        # For some reason this is actually using a symbol to represent a null
+        # object ref instead of nil itself, so just replacing it here for
+        # simplicity in the printer
+        json[:value][:object_ref] = nil if json[:value][:object_ref] == :nil
+
+        # Get a reference to the dynamic attributes hash
+        dynamic_attributes = value[:dynamic_attributes].to_h
+
+        # If we have any in the old style, then we're going to pass it through
+        # the deep attribute parser filter.
+        if dynamic_attributes[:old]
+          dynamic_attributes[:old] =
+            DeepAttributeParser.new.parse(dynamic_attributes[:old])
+        end
+
+        json.merge!(
+          children: children.map(&:as_json),
+          value: value.merge(dynamic_attributes: dynamic_attributes)
+        )
+      end
+    else
+      raise ArgumentError, "Unsupported type: #{type}"
+    end
+  end
+end
+
+module Prettier
+  class HAMLParser
+    def self.parse(source)
+      Haml::Parser.new({}).call(source).as_json
+    rescue StandardError
+      false
+    end
+  end
+end
+
+# If this is the main file we're executing, then most likely this is being
+# executed from the haml.js spawn. In that case, read the ruby source from
+# stdin and report back the AST over stdout.
+if $0 == __FILE__
+  response = Prettier::HAMLParser.parse($stdin.read)
+
+  if !response
+    warn(
+      '@prettier/plugin-ruby encountered an error when attempting to parse ' \
+        'the HAML source. This usually means there was a syntax error in the ' \
+        'file in question.'
+    )
+
+    exit 1
+  end
+
+  puts JSON.fast_generate(response)
+end

data/src/haml/printer.js

@@ -0,0 +1,28 @@
+const embed = require("./embed");
+const nodes = {
+  comment: require("./nodes/comment"),
+  doctype: require("./nodes/doctype"),
+  filter: require("./nodes/filter"),
+  haml_comment: require("./nodes/hamlComment"),
+  plain: require("./nodes/plain"),
+  root: require("./nodes/root"),
+  script: require("./nodes/script"),
+  silent_script: require("./nodes/silentScript"),
+  tag: require("./nodes/tag")
+};
+
+const genericPrint = (path, opts, print) => {
+  const { type } = path.getValue();
+
+  /* istanbul ignore next */
+  if (!(type in nodes)) {
+    throw new Error(`Unsupported node encountered: ${type}`);
+  }
+
+  return nodes[type](path, opts, print);
+};
+
+module.exports = {
+  embed,
+  print: genericPrint
+};

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

@@ -1,5 +1,11 @@
-const printer = require("./printer");
-const parser = require("./parser");
+const rubyPrinter = require("./ruby/printer");
+const rubyParser = require("./ruby/parser");
+
+const rbsPrinter = require("./rbs/printer");
+const rbsParser = require("./rbs/parser");
+
+const hamlPrinter = require("./haml/printer");
+const hamlParser = require("./haml/parser");
 
 /*
  * metadata mostly pulled from linguist and rubocop:
@@ -67,13 +73,28 @@ module.exports = {
       interpreters: ["jruby", "macruby", "rake", "rbx", "ruby"],
       linguistLanguageId: 326,
       vscodeLanguageIds: ["ruby"]
+    },
+    {
+      name: "RBS",
+      parsers: ["rbs"],
+      extensions: [".rbs"]
+    },
+    {
+      name: "HAML",
+      parsers: ["haml"],
+      extensions: [".haml"],
+      vscodeLanguageIds: ["haml"]
     }
   ],
   parsers: {
-    ruby: parser
+    ruby: rubyParser,
+    rbs: rbsParser,
+    haml: hamlParser
   },
   printers: {
-    ruby: printer
+    ruby: rubyPrinter,
+    rbs: rbsPrinter,
+    haml: hamlPrinter
   },
   options: {
     rubyArrayLiteral: {

data/src/prettier.js

@@ -1,6 +1,7 @@
 // If `RBPRETTIER` is set, then this is being run from the `Prettier::run` ruby
 // method. In that case, we need to pull `prettier` from the node_modules
 // directly, as it's been shipped with the gem.
+/* istanbul ignore next */
 const source = process.env.RBPRETTIER ? "../node_modules/prettier" : "prettier";
 
 const prettier = require(source);

data/src/rbs/parser.js

@@ -0,0 +1,51 @@
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+// 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", [path.join(__dirname, "./parser.rb")], {
+    input: text,
+    maxBuffer: 15 * 1024 * 1024 // 15MB
+  });
+
+  const error = child.stderr.toString();
+  if (error) {
+    throw new Error(error);
+  }
+
+  const response = child.stdout.toString();
+  return JSON.parse(response);
+}
+
+const pragmaPattern = /#\s*@(prettier|format)/;
+
+// This function handles checking whether or not the source string has the
+// pragma for prettier. This is an optional workflow for incremental adoption.
+function hasPragma(text) {
+  return pragmaPattern.test(text);
+}
+
+// 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
+// beginning of the given node.
+function locStart(node) {
+  return (node.location || node.type.location).start_pos;
+}
+
+// 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.location || node.type.location).end_pos;
+}
+
+module.exports = {
+  parse,
+  astFormat: "rbs",
+  hasPragma,
+  locStart,
+  locEnd
+};

data/src/rbs/parser.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup' if ENV['CI']
+require 'json'
+require 'rbs'
+
+# Monkey-patch this so that we can get the character positions.
+class RBS::Location
+  def to_json(*args)
+    {
+      start: { line: start_line, column: start_column },
+      end: { line: end_line, column: end_column },
+      start_pos: start_pos,
+      end_pos: end_pos
+    }.to_json(*args)
+  end
+end
+
+class RBS::Types::Function::Param
+  def to_json(*a)
+    escaped = name && /\A#{RBS::Parser::KEYWORDS_RE}\z/.match?(name)
+    { type: type, name: name, escaped: escaped }.to_json(*a)
+  end
+end
+
+# Monkey-patch this so that we get the name field in the serialized JSON, as
+# well as information about whether or not we need to escape it.
+class RBS::AST::Members::MethodDefinition
+  def to_json(*a)
+    {
+      member: :method_definition,
+      name: name,
+      kind: kind,
+      types: types,
+      annotations: annotations,
+      location: location,
+      comment: comment,
+      overload: overload
+    }.to_json(*a)
+  end
+end
+
+# Monkey-patch this so that we get the information we need about how to join the
+# key-value pairs of the record.
+class RBS::Types::Record
+  def to_json(*a)
+    fields_extra = {}
+
+    # Explicitly not using Enumerable#to_h here to support Ruby 2.5
+    fields.each do |key, type|
+      if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/) &&
+           !key.match?(RBS::Parser::KEYWORDS_RE)
+        fields_extra[key] = { type: type, joiner: :label }
+      else
+        fields_extra[key.inspect] = { type: type, joiner: :rocket }
+      end
+    end
+
+    { class: :record, fields: fields_extra, location: location }.to_json(*a)
+  end
+end
+
+module Prettier
+  class RBSParser
+    def self.parse(text)
+      { declarations: RBS::Parser.parse_signature(text) }
+    rescue StandardError
+      false
+    end
+  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 rbs source from
+# stdin and report back the AST over stdout.
+
+if $0 == __FILE__
+  response = Prettier::RBSParser.parse($stdin.read)
+
+  if !response
+    warn(
+      '@prettier/plugin-ruby encountered an error when attempting to parse ' \
+        'the RBS source. This usually means there was a syntax error in the ' \
+        'file in question.'
+    )
+
+    exit 1
+  end
+
+  puts JSON.fast_generate(response)
+end

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
+};