prettier 0.20.0 → 1.0.0.pre.rc2

data/src/nodes/super.js

@@ -0,0 +1,35 @@
+const { align, concat, group, join, line } = require("../prettier");
+const { literal } = require("../utils");
+
+function printSuper(path, opts, print) {
+  const args = path.getValue().body[0];
+
+  if (args.type === "arg_paren") {
+    // In case there are explicitly no arguments but they are using parens,
+    // we assume they are attempting to override the initializer and pass no
+    // arguments up.
+    if (args.body[0] === null) {
+      return "super()";
+    }
+
+    return concat(["super", path.call(print, "body", 0)]);
+  }
+
+  const keyword = "super ";
+  const argsDocs = path.call(print, "body", 0);
+
+  return group(
+    concat([
+      keyword,
+      align(keyword.length, group(join(concat([",", line]), argsDocs)))
+    ])
+  );
+}
+
+// Version of super without any parens or args.
+const printZSuper = literal("super");
+
+module.exports = {
+  super: printSuper,
+  zsuper: printZSuper
+};

data/src/nodes/undef.js

@@ -0,0 +1,42 @@
+const {
+  addTrailingComment,
+  align,
+  concat,
+  group,
+  join,
+  line
+} = require("../prettier");
+
+function printUndefSymbol(path, opts, print) {
+  const node = path.getValue();
+
+  // Since we're going to descend into the symbol literal to grab out the ident
+  // node, then we need to make sure we copy over any comments as well,
+  // otherwise we could accidentally skip printing them.
+  if (node.comments) {
+    node.comments.forEach((comment) => {
+      addTrailingComment(node.body[0], comment);
+    });
+  }
+
+  return path.call(print, "body", 0);
+}
+
+function printUndef(path, opts, print) {
+  const keyword = "undef ";
+  const argNodes = path.map(
+    (symbolPath) => printUndefSymbol(symbolPath, opts, print),
+    "body"
+  );
+
+  return group(
+    concat([
+      keyword,
+      align(keyword.length, join(concat([",", line]), argNodes))
+    ])
+  );
+}
+
+module.exports = {
+  undef: printUndef
+};

data/src/parser.js

@@ -0,0 +1,71 @@
+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. This object below represents all of
+// the possible values of process.platform per:
+//   https://nodejs.org/api/process.html#process_process_platform
+const LANG = {
+  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"
+}[process.platform];
+
+// 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);
+}
+
+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.char_start;
+}
+
+// This function is critical for comments and cursor support, and is responsible
+// for returning the index of the character within the source string that is the
+// ending of the given node.
+function locEnd(node) {
+  return node.char_end;
+}
+
+module.exports = {
+  parse,
+  astFormat: "ruby",
+  hasPragma,
+  locStart,
+  locEnd
+};

data/src/parser.rb

@@ -0,0 +1,2554 @@
+#!/usr/bin/env ruby
+
+# We implement our own version checking here instead of using Gem::Version so
+# that we can use the --disable-gems flag.
+RUBY_MAJOR, RUBY_MINOR, RUBY_PATCH, * = RUBY_VERSION.split('.').map(&:to_i)
+
+if (RUBY_MAJOR < 2) || ((RUBY_MAJOR == 2) && (RUBY_MINOR < 5))
+  warn(
+    "Ruby version #{RUBY_VERSION} not supported. " \
+      'Please upgrade to 2.5.0 or above.'
+  )
+
+  exit 1
+end
+
+require 'delegate'
+require 'json' unless defined?(JSON)
+require 'ripper'
+
+module Prettier; end
+
+class Prettier::Parser < Ripper
+  attr_reader :source, :lines, :scanner_events, :line_counts
+
+  def initialize(source, *args)
+    super(source, *args)
+
+    @source = source
+    @lines = source.split("\n")
+
+    @comments = []
+    @embdoc = nil
+    @__end__ = nil
+
+    @heredocs = []
+
+    @scanner_events = []
+    @line_counts = [0]
+
+    @source.lines.each { |line| @line_counts << @line_counts.last + line.size }
+  end
+
+  private
+
+  # This represents the current place in the source string that we've gotten to
+  # so far. We have a memoized line_counts object that we can use to get the
+  # number of characters that we've had to go through to get to the beginning of
+  # 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
+  end
+
+  # As we build up a list of scanner events, we'll periodically need to go
+  # backwards and find the ones that we've already hit in order to determine the
+  # location information for nodes that use them. For example, if you have a
+  # module node then you'll look backward for a @module scanner event to
+  # determine your start location.
+  #
+  # This works with nesting since we're deleting scanner events from the list
+  # once they've been used up. For example if you had nested module declarations
+  # then the innermost declaration would grab the last @module event (which
+  # would happen to be the innermost keyword). Then the outer one would only be
+  # able to grab the first one. In this way all of the scanner events act as
+  # their own stack.
+  def find_scanner_event(type, body = :any)
+    index =
+      scanner_events.rindex do |scanner_event|
+        scanner_event[:type] == type &&
+          (body == :any || (scanner_event[:body] == body))
+      end
+
+    scanner_events.delete_at(index)
+  end
+
+  # Scanner events occur when the lexer hits a new token, like a keyword or an
+  # end. These nodes always contain just one argument which is a string
+  # representing the content. For the most part these can just be printed
+  # directly, which very few exceptions.
+  defined = %i[
+    comment
+    embdoc
+    embdoc_beg
+    embdoc_end
+    heredoc_beg
+    heredoc_end
+    ignored_nl
+  ]
+
+  (SCANNER_EVENTS - defined).each do |event|
+    define_method(:"on_#{event}") do |value|
+      char_end = char_pos + value.size
+      node = {
+        type: :"@#{event}",
+        body: value,
+        start: lineno,
+        end: lineno,
+        char_start: char_pos,
+        char_end: char_end
+      }
+
+      scanner_events << node
+      node
+    end
+  end
+
+  # We keep track of each comment as it comes in and then eventually add
+  # them to the top of the generated AST so that prettier can start adding
+  # them back into the final representation. Comments come in including
+  # their starting pound sign and the newline at the end, so we also chop
+  # those off.
+  #
+  # If there is an encoding magic comment at the top of the file, ripper
+  # will actually change into that encoding for the storage of the string.
+  # This will break everything, so we need to force the encoding back into
+  # UTF-8 so that the JSON library won't break.
+  def on_comment(value)
+    @comments << {
+      type: :@comment,
+      value: value[1..-1].chomp.force_encoding('UTF-8'),
+      start: lineno,
+      end: lineno,
+      char_start: char_pos,
+      char_end: char_pos + value.length - 1
+    }
+  end
+
+  # ignored_nl is a special kind of scanner event that passes nil as the value,
+  # so we can't do our normal tracking of value.size. Instead of adding a
+  # condition to the main SCANNER_EVENTS loop above, we'll just explicitly
+  # define the method here. You can trigger the ignored_nl event with the
+  # following snippet:
+  #
+  #     foo.bar
+  #        .baz
+  #
+  def on_ignored_nl(value)
+    {
+      type: :ignored_nl,
+      body: nil,
+      start: lineno,
+      end: lineno,
+      char_start: char_pos,
+      char_end: char_pos
+    }
+  end
+
+  prepend(
+    Module.new do
+      private
+
+      # Handles __END__ syntax, which allows individual scripts to keep content
+      # after the main ruby code that can be read through DATA. It looks like:
+      #
+      # foo.bar
+      #
+      # __END__
+      # some other content that isn't normally read by ripper
+      def on___end__(*)
+        @__end__ = super(lines[lineno..-1].join("\n"))
+      end
+
+      # Like comments, we need to force the encoding here so JSON doesn't break.
+      def on_ident(value)
+        super(value.force_encoding('UTF-8'))
+      end
+
+      # Like comments, we need to force the encoding here so JSON doesn't break.
+      def on_tstring_content(value)
+        super(value.force_encoding('UTF-8'))
+      end
+    end
+  )
+
+  # A BEGIN node is a parser event that represents the use of the BEGIN
+  # keyword, which hooks into the lifecycle of the interpreter. It's a bit
+  # of a legacy from the stream operating days, and gets its inspiration
+  # from tools like awk. Whatever is inside the "block" will get executed
+  # when the program starts. The syntax looks like the following:
+  #
+  #     BEGIN {
+  #       # execute stuff here
+  #     }
+  #
+  def on_BEGIN(stmts)
+    beging = find_scanner_event(:@lbrace)
+    ending = find_scanner_event(:@rbrace)
+
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
+
+    find_scanner_event(:@kw, 'BEGIN').merge!(
+      type: :BEGIN,
+      body: [beging, stmts],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    )
+  end
+
+  # A END node is a parser event that represents the use of the END keyword,
+  # which hooks into the lifecycle of the interpreter. It's a bit of a
+  # legacy from the stream operating days, and gets its inspiration from
+  # tools like awk. Whatever is inside the "block" will get executed when
+  # the program ends. The syntax looks like the following:
+  #
+  #     END {
+  #       # execute stuff here
+  #     }
+  #
+  def on_END(stmts)
+    beging = find_scanner_event(:@lbrace)
+    ending = find_scanner_event(:@rbrace)
+
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
+
+    find_scanner_event(:@kw, 'END').merge!(
+      type: :END,
+      body: [beging, stmts],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    )
+  end
+
+  # alias is a parser event that represents when you're using the alias
+  # keyword with regular arguments. This can be either symbol literals or
+  # bare words. You can optionally use parentheses with this keyword, so we
+  # either track the location information based on those or the final
+  # argument to the alias method.
+  def on_alias(left, right)
+    beging = find_scanner_event(:@kw, 'alias')
+
+    paren = source[beging[:char_end]...left[:char_start]].include?('(')
+    ending = paren ? find_scanner_event(:@rparen) : right
+
+    {
+      type: :alias,
+      body: [left, right],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # aref nodes are when you're pulling a value out of a collection at a
+  # specific index. Put another way, it's any time you're calling the method
+  # #[]. As an example:
+  #
+  #     foo[index]
+  #
+  # The nodes usually contains two children, the collection and the index.
+  # In some cases, you don't necessarily have the second child node, because
+  # you can call procs with a pretty esoteric syntax. In the following
+  # example, you wouldn't have a second child, and "foo" would be the first
+  # child:
+  #
+  #     foo[]
+  #
+  def on_aref(collection, index)
+    find_scanner_event(:@lbracket)
+    ending = find_scanner_event(:@rbracket)
+
+    {
+      type: :aref,
+      body: [collection, index],
+      start: collection[:start],
+      char_start: collection[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # aref_field is a parser event that is very similar to aref except that it
+  # is being used inside of an assignment.
+  def on_aref_field(collection, index)
+    find_scanner_event(:@lbracket)
+    ending = find_scanner_event(:@rbracket)
+
+    {
+      type: :aref_field,
+      body: [collection, index],
+      start: collection[:start],
+      char_start: collection[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # args_new is a parser event that represents the beginning of a list of
+  # arguments to any method call or an array. It can be followed by any
+  # number of args_add events, which we'll append onto an array body.
+  def on_args_new
+    {
+      type: :args,
+      body: [],
+      start: lineno,
+      char_start: char_pos,
+      end: lineno,
+      char_end: char_pos
+    }
+  end
+
+  # args_add is a parser event that represents a single argument inside a
+  # list of arguments to any method call or an array. It accepts as
+  # arguments the parent args node as well as an arg which can be anything
+  # that could be passed as an argument.
+  def on_args_add(args, arg)
+    if args[:body].empty?
+      arg.merge(type: :args, body: [arg])
+    else
+      args.merge!(
+        body: args[:body] << arg, end: arg[:end], char_end: arg[:char_end]
+      )
+    end
+  end
+
+  # args_add_block is a parser event that represents a list of arguments and
+  # potentially a block argument. If no block is passed, then the second
+  # argument will be false.
+  def on_args_add_block(args, block)
+    ending = block || args
+
+    args.merge(
+      type: :args_add_block,
+      body: [args, block],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    )
+  end
+
+  # args_add_star is a parser event that represents adding a splat of values
+  # to a list of arguments. If accepts as arguments the parent args node as
+  # well as the part that is being splatted.
+  def on_args_add_star(args, part)
+    beging = find_scanner_event(:@op, '*')
+    ending = part || beging
+
+    {
+      type: :args_add_star,
+      body: [args, part],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # args_forward is a parser event that represents forwarding all kinds of
+  # arguments onto another method call.
+  def on_args_forward
+    find_scanner_event(:@op, '...').merge!(type: :args_forward)
+  end
+
+  # arg_paren is a parser event that represents wrapping arguments to a
+  # method inside a set of parentheses.
+  def on_arg_paren(args)
+    beging = find_scanner_event(:@lparen)
+    rparen = find_scanner_event(:@rparen)
+
+    # 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
+
+    {
+      type: :arg_paren,
+      body: [args],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # Array nodes can contain a myriad of subnodes because of the special
+  # array literal syntax like %w and %i. As a result, we may be looking for
+  # an left bracket, or we may be just looking at the children to get the
+  # bounds.
+  def on_array(contents)
+    if !contents || %i[args args_add_star].include?(contents[:type])
+      beging = find_scanner_event(:@lbracket)
+      ending = find_scanner_event(:@rbracket)
+
+      {
+        type: :array,
+        body: [contents],
+        start: beging[:start],
+        char_start: beging[:char_start],
+        end: ending[:end],
+        char_end: ending[:char_end]
+      }
+    else
+      ending = find_scanner_event(:@tstring_end)
+      contents[:char_end] = ending[:char_end]
+
+      ending.merge!(
+        type: :array,
+        body: [contents],
+        start: contents[:start],
+        char_start: contents[:char_start]
+      )
+    end
+  end
+
+  # aryptn is a parser event that represents matching against an array pattern
+  # using the Ruby 2.7+ pattern matching syntax.
+  def on_aryptn(const, preargs, splatarg, postargs)
+    pieces = [const, *preargs, splatarg, *postargs].compact
+
+    {
+      type: :aryptn,
+      body: [const, preargs, splatarg, postargs],
+      start: pieces[0][:start],
+      char_start: pieces[0][:char_start],
+      end: pieces[-1][:end],
+      char_end: pieces[-1][:char_end]
+    }
+  end
+
+  # assign is a parser event that represents assigning something to a
+  # variable or constant. It accepts as arguments the left side of the
+  # expression before the equals sign and the right side of the expression.
+  def on_assign(left, right)
+    left.merge(
+      type: :assign,
+      body: [left, right],
+      end: right[:end],
+      char_end: right[:char_end]
+    )
+  end
+
+  # assoc_new is a parser event that contains a key-value pair within a
+  # hash. It is a child event of either an assoclist_from_args or a
+  # bare_assoc_hash.
+  def on_assoc_new(key, value)
+    {
+      type: :assoc_new,
+      body: [key, value],
+      start: key[:start],
+      char_start: key[:char_start],
+      end: value[:end],
+      char_end: value[:char_end]
+    }
+  end
+
+  # assoc_splat is a parser event that represents splatting a value into a
+  # hash (either a hash literal or a bare hash in a method call).
+  def on_assoc_splat(contents)
+    find_scanner_event(:@op, '**').merge!(
+      type: :assoc_splat,
+      body: [contents],
+      end: contents[:end],
+      char_end: contents[:char_end]
+    )
+  end
+
+  # assoclist_from_args is a parser event that contains a list of all of the
+  # associations inside of a hash literal. Its parent node is always a hash.
+  # It accepts as an argument an array of assoc events (either assoc_new or
+  # assoc_splat).
+  def on_assoclist_from_args(assocs)
+    {
+      type: :assoclist_from_args,
+      body: assocs,
+      start: assocs[0][:start],
+      char_start: assocs[0][:char_start],
+      end: assocs[-1][:end],
+      char_end: assocs[-1][:char_end]
+    }
+  end
+
+  # bare_assoc_hash is a parser event that represents a hash of contents
+  # being passed as a method argument (and therefore has omitted braces). It
+  # accepts as an argument an array of assoc events (either assoc_new or
+  # assoc_splat).
+  def on_bare_assoc_hash(assoc_news)
+    {
+      type: :bare_assoc_hash,
+      body: assoc_news,
+      start: assoc_news[0][:start],
+      char_start: assoc_news[0][:char_start],
+      end: assoc_news[-1][:end],
+      char_end: assoc_news[-1][:char_end]
+    }
+  end
+
+  # begin is a parser event that represents the beginning of a begin..end chain.
+  # It includes a bodystmt event that has all of the consequent clauses.
+  def on_begin(bodystmt)
+    beging = find_scanner_event(:@kw, 'begin')
+    char_end =
+      if bodystmt[:body][1..-1].any?
+        bodystmt[:char_end]
+      else
+        find_scanner_event(:@kw, 'end')[:char_end]
+      end
+
+    bodystmt.bind(beging[:char_end], char_end)
+
+    beging.merge!(
+      type: :begin,
+      body: [bodystmt],
+      end: bodystmt[:end],
+      char_end: bodystmt[:char_end]
+    )
+  end
+
+  # binary is a parser event that represents a binary operation between two
+  # values.
+  def on_binary(left, oper, right)
+    {
+      type: :binary,
+      body: [left, oper, right],
+      start: left[:start],
+      char_start: left[:char_start],
+      end: right[:end],
+      char_end: right[:char_end]
+    }
+  end
+
+  # block_var is a parser event that represents the parameters being passed to
+  # block. Effectively they're everything contained within the pipes.
+  def on_block_var(params, locals)
+    index =
+      scanner_events.rindex do |event|
+        event[:type] == :@op && %w[| ||].include?(event[:body]) &&
+          event[:char_start] < params[:char_start]
+      end
+
+    beging = scanner_events[index]
+    ending = scanner_events[-1]
+
+    {
+      type: :block_var,
+      body: [params, locals],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # blockarg is a parser event that represents defining a block variable on
+  # a method definition.
+  def on_blockarg(ident)
+    find_scanner_event(:@op, '&').merge!(
+      type: :blockarg,
+      body: [ident],
+      end: ident[:end],
+      char_end: ident[:char_end]
+    )
+  end
+
+  # bodystmt can't actually determine its bounds appropriately because it
+  # doesn't necessarily know where it started. So the parent node needs to
+  # report back down into this one where it goes.
+  class BodyStmt < SimpleDelegator
+    def bind(char_start, char_end)
+      merge!(char_start: char_start, char_end: char_end)
+      parts = self[:body]
+
+      # Here we're going to determine the bounds for the stmts
+      consequent = parts[1..-1].compact.first
+      self[:body][0].bind(
+        char_start,
+        consequent ? consequent[:char_start] : char_end
+      )
+
+      # Next we're going to determine the rescue clause if there is one
+      if parts[1]
+        consequent = parts[2..-1].compact.first
+        self[:body][1].bind_end(consequent ? consequent[:char_start] : char_end)
+      end
+    end
+  end
+
+  # bodystmt is a parser event that represents all of the possible combinations
+  # of clauses within the body of a method or block.
+  def on_bodystmt(stmts, rescued, ensured, elsed)
+    BodyStmt.new(
+      type: :bodystmt,
+      body: [stmts, rescued, ensured, elsed],
+      start: lineno,
+      char_start: char_pos,
+      end: lineno,
+      char_end: char_pos
+    )
+  end
+
+  # brace_block is a parser event that represents passing a block to a
+  # method call using the {..} operators. It accepts as arguments an
+  # optional block_var event that represents any parameters to the block as
+  # well as a stmts event that represents the statements inside the block.
+  def on_brace_block(block_var, stmts)
+    beging = find_scanner_event(:@lbrace)
+    ending = find_scanner_event(:@rbrace)
+
+    stmts.bind((block_var || beging)[:char_end], ending[:char_start])
+
+    {
+      type: :brace_block,
+      body: [block_var, stmts],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # break is a parser event that represents using the break keyword. It
+  # accepts as an argument an args or args_add_block event that contains all
+  # of the arguments being passed to the break.
+  def on_break(args_add_block)
+    beging = find_scanner_event(:@kw, 'break')
+
+    # You can hit this if you are passing no arguments to break but it has a
+    # comment right after it. In that case we can just use the location
+    # information straight from the keyword.
+    if args_add_block[:type] == :args
+      return beging.merge!(type: :break, body: [args_add_block])
+    end
+
+    beging.merge!(
+      type: :break,
+      body: [args_add_block],
+      end: args_add_block[:end],
+      char_end: args_add_block[:char_end]
+    )
+  end
+
+  # call is a parser event representing a method call with no arguments. It
+  # accepts as arguments the receiver of the method, the operator being used
+  # to send the method (., ::, or &.), and the value that is being sent to
+  # the receiver (which can be another nested call as well).
+  #
+  # There is one esoteric syntax that comes into play here as well. If the
+  # sending argument to this method is the symbol :call, then it represents
+  # calling a lambda in a very odd looking way, as in:
+  #
+  #     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
+      ending = oper
+
+      # Special handling here for Ruby <= 2.5 because the oper argument to this
+      # method wasn't a parser event here it was just a plain symbol.
+      ending = receiver if RUBY_MAJOR <= 2 && RUBY_MINOR <= 5
+    end
+
+    {
+      type: :call,
+      body: [receiver, oper, sending],
+      start: receiver[:start],
+      char_start: receiver[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # case is a parser event that represents the beginning of a case chain.
+  # It accepts as arguments the switch of the case and the consequent
+  # clause.
+  def on_case(switch, consequent)
+    find_scanner_event(:@kw, 'case').merge!(
+      type: :case,
+      body: [switch, consequent],
+      end: consequent[:end],
+      char_end: consequent[:char_end]
+    )
+  end
+
+  # Finds the next position in the source string that begins a statement. This
+  # is used to bind statements lists and make sure they don't include a
+  # preceding comment. For example, we want the following comment to be attached
+  # to the class node and not the statement node:
+  #
+  #     class Foo # :nodoc:
+  #       ...
+  #     end
+  #
+  # By finding the next non-space character, we can make sure that the bounds of
+  # the statement list are correct.
+  def find_next_statement_start(position)
+    remaining = source[position..-1]
+
+    if remaining.sub(/\A +/, '')[0] == '#'
+      return position + remaining.index("\n")
+    end
+
+    position
+  end
+
+  # class is a parser event that represents defining a class. It accepts as
+  # arguments the name of the class, the optional name of the superclass,
+  # and the bodystmt event that represents the statements evaluated within
+  # the context of the class.
+  def on_class(const, superclass, bodystmt)
+    beging = find_scanner_event(:@kw, 'class')
+    ending = find_scanner_event(:@kw, 'end')
+
+    bodystmt.bind(
+      find_next_statement_start((superclass || const)[:char_end]),
+      ending[:char_start]
+    )
+
+    {
+      type: :class,
+      body: [const, superclass, bodystmt],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # command is a parser event representing a method call with arguments and
+  # no parentheses. It accepts as arguments the name of the method and the
+  # arguments being passed to the method.
+  def on_command(ident, args)
+    {
+      type: :command,
+      body: [ident, args],
+      start: ident[:start],
+      char_start: ident[:char_start],
+      end: args[:end],
+      char_end: args[:char_end]
+    }
+  end
+
+  # command_call is a parser event representing a method call on an object
+  # with arguments and no parentheses. It accepts as arguments the receiver
+  # 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)
+    ending = args || ident
+
+    {
+      type: :command_call,
+      body: [receiver, oper, ident, args],
+      start: receiver[:start],
+      char_start: receiver[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # A const_path_field is a parser event that is always the child of some
+  # kind of assignment. It represents when you're assigning to a constant
+  # that is being referenced as a child of another variable. For example:
+  #
+  #     foo::X = 1
+  #
+  def on_const_path_field(left, const)
+    {
+      type: :const_path_field,
+      body: [left, const],
+      start: left[:start],
+      char_start: left[:char_start],
+      end: const[:end],
+      char_end: const[:char_end]
+    }
+  end
+
+  # A const_path_ref is a parser event that is a very similar to
+  # const_path_field except that it is not involved in an assignment. It
+  # looks like the following example:
+  #
+  #     foo::X
+  #
+  def on_const_path_ref(left, const)
+    {
+      type: :const_path_ref,
+      body: [left, const],
+      start: left[:start],
+      char_start: left[:char_start],
+      end: const[:end],
+      char_end: const[:char_end]
+    }
+  end
+
+  # A const_ref is a parser event that represents the name of the constant
+  # being used in a class or module declaration. In the following example it
+  # is the @const scanner event that has the contents of Foo.
+  #
+  #     class Foo; end
+  #
+  def on_const_ref(const)
+    const.merge(type: :const_ref, body: [const])
+  end
+
+  # A def is a parser event that represents defining a regular method on the
+  # current self object. It accepts as arguments the ident (the name of the
+  # method being defined), the params (the parameter declaration for the
+  # method), and a bodystmt node which represents the statements inside the
+  # method. As an example, here are the parts that go into this:
+  #
+  #     def foo(bar) do baz end
+  #          │   │       │
+  #          │   │       └> bodystmt
+  #          │   └> params
+  #          └> ident
+  #
+  def on_def(ident, params, bodystmt)
+    # Make sure to delete this scanner event in case you're defining something
+    # like def class which would lead to this being a kw and causing all kinds
+    # of trouble
+    scanner_events.delete(ident)
+
+    if params[:type] == :params && !params[:body].any?
+      location = ident[:char_end]
+      params.merge!(char_start: location, char_end: location)
+    end
+
+    beging = find_scanner_event(:@kw, 'def')
+    ending = find_scanner_event(:@kw, 'end')
+
+    bodystmt.bind(
+      find_next_statement_start(params[:char_end]),
+      ending[:char_start]
+    )
+
+    {
+      type: :def,
+      body: [ident, params, bodystmt],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # A defs is a parser event that represents defining a singleton method on
+  # an object. It accepts the same arguments as the def event, as well as
+  # the target and operator that on which this method is being defined. As
+  # an example, here are the parts that go into this:
+  #
+  #     def foo.bar(baz) do baz end
+  #          │ │ │   │       │
+  #          │ │ │   │       │
+  #          │ │ │   │       └> bodystmt
+  #          │ │ │   └> params
+  #          │ │ └> ident
+  #          │ └> oper
+  #          └> target
+  #
+  def on_defs(target, oper, ident, params, bodystmt)
+    # Make sure to delete this scanner event in case you're defining something
+    # like def class which would lead to this being a kw and causing all kinds
+    # of trouble
+    scanner_events.delete(ident)
+
+    if params[:type] == :params && !params[:body].any?
+      location = ident[:char_end]
+      params.merge!(char_start: location, char_end: location)
+    end
+
+    beging = find_scanner_event(:@kw, 'def')
+    ending = find_scanner_event(:@kw, 'end')
+
+    bodystmt.bind(
+      find_next_statement_start(params[:char_end]),
+      ending[:char_start]
+    )
+
+    {
+      type: :defs,
+      body: [target, oper, ident, params, bodystmt],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # A defined node represents the rather unique defined? operator. It can be
+  # used with and without parentheses. If they're present, we use them to
+  # determine our bounds, otherwise we use the value that's being passed to
+  # the operator.
+  def on_defined(value)
+    beging = find_scanner_event(:@kw, 'defined?')
+
+    paren = source[beging[:char_end]...value[:char_start]].include?('(')
+    ending = paren ? find_scanner_event(:@rparen) : value
+
+    beging.merge!(
+      type: :defined,
+      body: [value],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    )
+  end
+
+  # do_block is a parser event that represents passing a block to a method
+  # call using the do..end keywords. It accepts as arguments an optional
+  # block_var event that represents any parameters to the block as well as
+  # a bodystmt event that represents the statements inside the block.
+  def on_do_block(block_var, bodystmt)
+    beging = find_scanner_event(:@kw, 'do')
+    ending = find_scanner_event(:@kw, 'end')
+
+    bodystmt.bind((block_var || beging)[:char_end], ending[:char_start])
+
+    {
+      type: :do_block,
+      body: [block_var, bodystmt],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # dot2 is a parser event that represents using the .. operator between two
+  # expressions. Usually this is to create a range object but sometimes it's to
+  # use the flip-flop operator.
+  def on_dot2(left, right)
+    operator = find_scanner_event(:@op, '..')
+
+    beging = left || operator
+    ending = right || operator
+
+    {
+      type: :dot2,
+      body: [left, right],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # dot3 is a parser event that represents using the ... operator between two
+  # expressions. Usually this is to create a range object but sometimes it's to
+  # use the flip-flop operator.
+  def on_dot3(left, right)
+    operator = find_scanner_event(:@op, '...')
+
+    beging = left || operator
+    ending = right || operator
+
+    {
+      type: :dot3,
+      body: [left, right],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # A dyna_symbol is a parser event that represents a symbol literal that
+  # uses quotes to interpolate its value. For example, if you had a variable
+  # foo and you wanted a symbol that contained its value, you would write:
+  #
+  #     :"#{foo}"
+  #
+  # As such, they accept as one argument a string node, which is the same
+  # node that gets accepted into a string_literal (since we're basically
+  # talking about a string literal with a : character at the beginning).
+  #
+  # They can also come in another flavor which is a dynamic symbol as a hash
+  # key. This is kind of an interesting syntax which results in us having to
+  # look for a @label_end scanner event instead to get our bearings. That
+  # kind of code would look like:
+  #
+  #     { "#{foo}": bar }
+  #
+  # which would be the same symbol as above.
+  def on_dyna_symbol(string)
+    if scanner_events.any? { |event| event[:type] == :@symbeg }
+      # A normal dynamic symbol
+      beging = find_scanner_event(:@symbeg)
+      ending = find_scanner_event(:@tstring_end)
+
+      beging.merge(
+        type: :dyna_symbol,
+        quote: beging[:body][1],
+        body: string[:body],
+        end: ending[:end],
+        char_end: ending[:char_end]
+      )
+    else
+      # A dynamic symbol as a hash key
+      beging = find_scanner_event(:@tstring_beg)
+      ending = find_scanner_event(:@label_end)
+
+      string.merge!(
+        type: :dyna_symbol,
+        quote: ending[:body][0],
+        start: beging[:start],
+        char_start: beging[:char_start],
+        end: ending[:end],
+        char_end: ending[:char_end]
+      )
+    end
+  end
+
+  # else can either end with an end keyword (in which case we'll want to
+  # consume that event) or it can end with an ensure keyword (in which case
+  # we'll leave that to the ensure to handle).
+  def find_else_ending
+    index =
+      scanner_events.rindex do |event|
+        event[:type] == :@kw && %w[end ensure].include?(event[:body])
+      end
+
+    event = scanner_events[index]
+    event[:body] == 'end' ? scanner_events.delete_at(index) : event
+  end
+
+  # else is a parser event that represents the end of a if, unless, or begin
+  # chain. It accepts as an argument the statements that are contained
+  # within the else clause.
+  def on_else(stmts)
+    beging = find_scanner_event(:@kw, 'else')
+    ending = find_else_ending
+
+    stmts.bind(beging[:char_end], ending[:char_start])
+
+    {
+      type: :else,
+      body: [stmts],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # elsif is a parser event that represents another clause in an if chain.
+  # It accepts as arguments the predicate of the else if, the statements
+  # that are contained within the else if clause, and the optional
+  # consequent clause.
+  def on_elsif(predicate, stmts, consequent)
+    beging = find_scanner_event(:@kw, 'elsif')
+    ending = consequent || find_scanner_event(:@kw, 'end')
+
+    stmts.bind(predicate[:char_end], ending[:char_start])
+
+    {
+      type: :elsif,
+      body: [predicate, stmts, consequent],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # embdocs are long comments that are surrounded by =begin..=end. They
+  # cannot be nested, so we don't need to worry about keeping a stack around
+  # like we do with heredocs. Instead we can just track the current embdoc
+  # and add to it as we get content. It always starts with this scanner
+  # event, so here we'll initialize the current embdoc.
+  def on_embdoc_beg(value)
+    @embdoc = {
+      type: :@embdoc,
+      value: value,
+      start: lineno,
+      char_start: char_pos
+    }
+  end
+
+  # This is a scanner event that gets hit when we're inside an embdoc and
+  # receive a new line of content. Here we are guaranteed to already have
+  # initialized the @embdoc variable so we can just append the new line onto
+  # the existing content.
+  def on_embdoc(value)
+    @embdoc[:value] << value
+  end
+
+  # This is the final scanner event for embdocs. It receives the =end. Here
+  # we can finalize the embdoc with its location information and the final
+  # piece of the string. We then add it to the list of comments so that
+  # prettier can place it into the final source string.
+  def on_embdoc_end(value)
+    @comments <<
+      @embdoc.merge!(
+        value: @embdoc[:value] << value.chomp,
+        end: lineno,
+        char_end: char_pos + value.length - 1
+      )
+
+    @embdoc = nil
+  end
+
+  # ensure is a parser event that represents the use of the ensure keyword
+  # and its subsequent statements.
+  def on_ensure(stmts)
+    beging = find_scanner_event(:@kw, 'ensure')
+
+    # Specifically not using find_scanner_event here because we don't want to
+    # consume the :@end event, because that would break def..ensure..end chains.
+    index =
+      scanner_events.rindex do |scanner_event|
+        scanner_event[:type] == :@kw && scanner_event[:body] == 'end'
+      end
+
+    ending = scanner_events[index]
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
+
+    {
+      type: :ensure,
+      body: [beging, stmts],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # An excessed_comma is a special kind of parser event that represents a comma
+  # at the end of a list of parameters. It's a very strange node. It accepts a
+  # different number of arguments depending on Ruby version, which is why we
+  # have the anonymous splat there.
+  def on_excessed_comma(*)
+    find_scanner_event(:@comma).merge!(type: :excessed_comma)
+  end
+
+  # An fcall is a parser event that represents the piece of a method call
+  # that comes before any arguments (i.e., just the name of the method).
+  def on_fcall(ident)
+    ident.merge(type: :fcall, body: [ident])
+  end
+
+  # A field is a parser event that is always the child of an assignment. It
+  # accepts as arguments the left side of operation, the operator (. or ::),
+  # and the right side of the operation. For example:
+  #
+  #     foo.x = 1
+  #
+  def on_field(left, oper, right)
+    {
+      type: :field,
+      body: [left, oper, right],
+      start: left[:start],
+      char_start: left[:char_start],
+      end: right[:end],
+      char_end: right[:char_end]
+    }
+  end
+
+  # for is a parser event that represents using the somewhat esoteric for
+  # loop. It accepts as arguments an ident which is the iterating variable,
+  # an enumerable for that which is being enumerated, and a stmts event that
+  # represents the statements inside the for loop.
+  def on_for(ident, enumerable, stmts)
+    beging = find_scanner_event(:@kw, 'for')
+    ending = find_scanner_event(:@kw, 'end')
+
+    stmts.bind(enumerable[:char_end], ending[:char_start])
+
+    {
+      type: :for,
+      body: [ident, enumerable, stmts],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # hash is a parser event that represents a hash literal. It accepts as an
+  # argument an optional assoclist_from_args event which contains the
+  # contents of the hash.
+  def on_hash(assoclist_from_args)
+    beging = find_scanner_event(:@lbrace)
+    ending = find_scanner_event(:@rbrace)
+
+    if assoclist_from_args
+      # Here we're going to expand out the location information for the assocs
+      # node so that it can grab up any remaining comments inside the hash.
+      assoclist_from_args.merge!(
+        char_start: beging[:char_end], char_end: ending[:char_start]
+      )
+    end
+
+    {
+      type: :hash,
+      body: [assoclist_from_args],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # This is a scanner event that represents the beginning of the heredoc. It
+  # includes the declaration (which we call beging here, which is just short
+  # for beginning). The declaration looks something like <<-HERE or <<~HERE.
+  # If the downcased version of the declaration actually matches an existing
+  # prettier parser, we'll later attempt to print it using that parser and
+  # printer through our embed function.
+  def on_heredoc_beg(beging)
+    location = {
+      start: lineno,
+      end: lineno,
+      char_start: char_pos,
+      char_end: char_pos + beging.length + 1
+    }
+
+    # Here we're going to artificially create an extra node type so that if
+    # there are comments after the declaration of a heredoc, they get printed.
+    location
+      .merge(
+        type: :heredoc,
+        beging: location.merge(type: :@heredoc_beg, body: beging)
+      )
+      .tap { |node| @heredocs << node }
+  end
+
+  # This is a parser event that occurs when you're using a heredoc with a
+  # tilde. These are considered `heredoc_dedent` nodes, whereas the hyphen
+  # heredocs show up as string literals.
+  def on_heredoc_dedent(string, _width)
+    @heredocs[-1].merge!(body: string[:body])
+  end
+
+  # This is a scanner event that represents the end of the heredoc.
+  def on_heredoc_end(ending)
+    @heredocs[-1].merge!(ending: ending.chomp, end: lineno, char_end: char_pos)
+  end
+
+  # hshptn is a parser event that represents matching against a hash pattern
+  # using the Ruby 2.7+ pattern matching syntax.
+  def on_hshptn(const, kw, kwrest)
+    pieces = [const, kw, kwrest].flatten(2).compact
+
+    {
+      type: :hshptn,
+      body: [const, kw, kwrest],
+      start: pieces[0][:start],
+      char_start: pieces[0][:char_start],
+      end: pieces[-1][:end],
+      char_end: pieces[-1][:char_end]
+    }
+  end
+
+  # if is a parser event that represents the first clause in an if chain.
+  # It accepts as arguments the predicate of the if, the statements that are
+  # contained within the if clause, and the optional consequent clause.
+  def on_if(predicate, stmts, consequent)
+    beging = find_scanner_event(:@kw, 'if')
+    ending = consequent || find_scanner_event(:@kw, 'end')
+
+    stmts.bind(predicate[:char_end], ending[:char_start])
+
+    {
+      type: :if,
+      body: [predicate, stmts, consequent],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # ifop is a parser event that represents a ternary operator. It accepts as
+  # arguments the predicate to the ternary, the truthy clause, and the falsy
+  # clause.
+  def on_ifop(predicate, truthy, falsy)
+    predicate.merge(
+      type: :ifop,
+      body: [predicate, truthy, falsy],
+      end: falsy[:end],
+      char_end: falsy[:char_end]
+    )
+  end
+
+  # if_mod is a parser event that represents the modifier form of an if
+  # statement. It accepts as arguments the predicate of the if and the
+  # statement that are contained within the if clause.
+  def on_if_mod(predicate, statement)
+    find_scanner_event(:@kw, 'if')
+
+    {
+      type: :if_mod,
+      body: [predicate, statement],
+      start: statement[:start],
+      char_start: statement[:char_start],
+      end: predicate[:end],
+      char_end: predicate[:char_end]
+    }
+  end
+
+  # in is a parser event that represents using the in keyword within the
+  # Ruby 2.7+ pattern matching syntax.
+  def on_in(pattern, stmts, consequent)
+    beging = find_scanner_event(:@kw, 'in')
+    ending = consequent || find_scanner_event(:@kw, 'end')
+
+    stmts.bind(beging[:char_end], ending[:char_start])
+
+    beging.merge!(
+      type: :in,
+      body: [pattern, stmts, consequent],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    )
+  end
+
+  # kwrest_param is a parser event that represents defining a parameter in a
+  # method definition that accepts all remaining keyword parameters.
+  def on_kwrest_param(ident)
+    oper = find_scanner_event(:@op, '**')
+    return oper.merge!(type: :kwrest_param, body: [nil]) unless ident
+
+    oper.merge!(
+      type: :kwrest_param,
+      body: [ident],
+      end: ident[:end],
+      char_end: ident[:char_end]
+    )
+  end
+
+  # lambda is a parser event that represents using a "stabby" lambda
+  # literal. It accepts as arguments a params event that represents any
+  # parameters to the lambda and a stmts event that represents the
+  # statements inside the lambda.
+  #
+  # It can be wrapped in either {..} or do..end so we look for either of
+  # those combinations to get our bounds.
+  def on_lambda(params, stmts)
+    beging = find_scanner_event(:@tlambda)
+
+    if scanner_events.any? { |event| event[:type] == :@tlambeg }
+      opening = find_scanner_event(:@tlambeg)
+      closing = find_scanner_event(:@rbrace)
+    else
+      opening = find_scanner_event(:@kw, 'do')
+      closing = find_scanner_event(:@kw, 'end')
+    end
+
+    stmts.bind(opening[:char_end], closing[:char_start])
+
+    {
+      type: :lambda,
+      body: [params, stmts],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: closing[:end],
+      char_end: closing[:char_end]
+    }
+  end
+
+  # massign is a parser event that is a parent node of any kind of multiple
+  # assignment. This includes splitting out variables on the left like:
+  #
+  #     a, b, c = foo
+  #
+  # as well as splitting out variables on the right, as in:
+  #
+  #     foo = a, b, c
+  #
+  # Both sides support splats, as well as variables following them. There's
+  # also slightly odd behavior that you can achieve with the following:
+  #
+  #     a, = foo
+  #
+  # In this case a would receive only the first value of the foo enumerable,
+  # in which case we need to explicitly track the comma and add it onto the
+  # child node.
+  def on_massign(left, right)
+    if source[left[:char_end]...right[:char_start]].strip.start_with?(',')
+      left[:comma] = true
+    end
+
+    {
+      type: :massign,
+      body: [left, right],
+      start: left[:start],
+      char_start: left[:char_start],
+      end: right[:end],
+      char_end: right[:char_end]
+    }
+  end
+
+  # method_add_arg is a parser event that represents a method call with
+  # arguments and parentheses. It accepts as arguments the method being called
+  # and the arg_paren event that contains the arguments to the method.
+  def on_method_add_arg(fcall, arg_paren)
+    # You can hit this if you are passing no arguments to a method that ends in
+    # a question mark. Because it knows it has to be a method and not a local
+    # variable. In that case we can just use the location information straight
+    # from the fcall.
+    if arg_paren[:type] == :args
+      return fcall.merge(type: :method_add_arg, body: [fcall, arg_paren])
+    end
+
+    {
+      type: :method_add_arg,
+      body: [fcall, arg_paren],
+      start: fcall[:start],
+      char_start: fcall[:char_start],
+      end: arg_paren[:end],
+      char_end: arg_paren[:char_end]
+    }
+  end
+
+  # method_add_block is a parser event that represents a method call with a
+  # block argument. It accepts as arguments the method being called and the
+  # block event.
+  def on_method_add_block(method_add_arg, block)
+    {
+      type: :method_add_block,
+      body: [method_add_arg, block],
+      start: method_add_arg[:start],
+      char_start: method_add_arg[:char_start],
+      end: block[:end],
+      char_end: block[:char_end]
+    }
+  end
+
+  # An mlhs_new is a parser event that represents the beginning of the left
+  # side of a multiple assignment. It is followed by any number of mlhs_add
+  # nodes that each represent another variable being assigned.
+  def on_mlhs_new
+    {
+      type: :mlhs,
+      body: [],
+      start: lineno,
+      char_start: char_pos,
+      end: lineno,
+      char_end: char_pos
+    }
+  end
+
+  # An mlhs_add is a parser event that represents adding another variable
+  # onto a list of assignments. It accepts as arguments the parent mlhs node
+  # as well as the part that is being added to the list.
+  def on_mlhs_add(mlhs, part)
+    if mlhs[:body].empty?
+      part.merge(type: :mlhs, body: [part])
+    else
+      mlhs.merge!(
+        body: mlhs[:body] << part, end: part[:end], char_end: part[:char_end]
+      )
+    end
+  end
+
+  # An mlhs_add_post is a parser event that represents adding another set of
+  # variables onto a list of assignments after a splat variable. It accepts
+  # as arguments the previous mlhs_add_star node that represented the splat
+  # as well another mlhs node that represents all of the variables after the
+  # splat.
+  def on_mlhs_add_post(mlhs_add_star, mlhs)
+    mlhs_add_star.merge(
+      type: :mlhs_add_post,
+      body: [mlhs_add_star, mlhs],
+      end: mlhs[:end],
+      char_end: mlhs[:char_end]
+    )
+  end
+
+  # An mlhs_add_star is a parser event that represents a splatted variable
+  # inside of a multiple assignment on the left hand side. It accepts as
+  # arguments the parent mlhs node as well as the part that represents the
+  # splatted variable.
+  def on_mlhs_add_star(mlhs, part)
+    beging = find_scanner_event(:@op, '*')
+    ending = part || beging
+
+    {
+      type: :mlhs_add_star,
+      body: [mlhs, part],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # An mlhs_paren is a parser event that represents parentheses being used
+  # to deconstruct values in a multiple assignment on the left hand side. It
+  # accepts as arguments the contents of the inside of the parentheses,
+  # which is another mlhs node.
+  def on_mlhs_paren(contents)
+    beging = find_scanner_event(:@lparen)
+    ending = find_scanner_event(:@rparen)
+
+    if source[beging[:char_end]...ending[:char_start]].strip.end_with?(',')
+      contents[:comma] = true
+    end
+
+    {
+      type: :mlhs_paren,
+      body: [contents],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # module is a parser event that represents defining a module. It accepts
+  # as arguments the name of the module and the bodystmt event that
+  # represents the statements evaluated within the context of the module.
+  def on_module(const, bodystmt)
+    beging = find_scanner_event(:@kw, 'module')
+    ending = find_scanner_event(:@kw, 'end')
+
+    bodystmt.bind(
+      find_next_statement_start(const[:char_end]),
+      ending[:char_start]
+    )
+
+    {
+      type: :module,
+      body: [const, bodystmt],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # An mrhs_new is a parser event that represents the beginning of a list of
+  # values that are being assigned within a multiple assignment node. It can
+  # be followed by any number of mrhs_add nodes that we'll build up into an
+  # array body.
+  def on_mrhs_new
+    {
+      type: :mrhs,
+      body: [],
+      start: lineno,
+      char_start: char_pos,
+      end: lineno,
+      char_end: char_pos
+    }
+  end
+
+  # An mrhs_add is a parser event that represents adding another value onto
+  # a list on the right hand side of a multiple assignment.
+  def on_mrhs_add(mrhs, part)
+    if mrhs[:body].empty?
+      part.merge(type: :mrhs, body: [part])
+    else
+      mrhs.merge!(
+        body: mrhs[:body] << part, end: part[:end], char_end: part[:char_end]
+      )
+    end
+  end
+
+  # An mrhs_add_star is a parser event that represents using the splat
+  # operator to expand out a value on the right hand side of a multiple
+  # assignment.
+  def on_mrhs_add_star(mrhs, part)
+    beging = find_scanner_event(:@op, '*')
+    ending = part || beging
+
+    {
+      type: :mrhs_add_star,
+      body: [mrhs, part],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # An mrhs_new_from_args is a parser event that represents the shorthand
+  # of a multiple assignment that allows you to assign values using just
+  # commas as opposed to assigning from an array. For example, in the
+  # following segment the right hand side of the assignment would trigger
+  # this event:
+  #
+  #     foo = 1, 2, 3
+  #
+  def on_mrhs_new_from_args(args)
+    args.merge(type: :mrhs_new_from_args, body: [args])
+  end
+
+  # next is a parser event that represents using the next keyword. It
+  # accepts as an argument an args or args_add_block event that contains all
+  # of the arguments being passed to the next.
+  def on_next(args_add_block)
+    find_scanner_event(:@kw, 'next').merge!(
+      type: :next,
+      body: [args_add_block],
+      end: args_add_block[:end],
+      char_end: args_add_block[:char_end]
+    )
+  end
+
+  # opassign is a parser event that represents assigning something to a
+  # variable or constant using an operator like += or ||=. It accepts as
+  # arguments the left side of the expression before the operator, the
+  # operator itself, and the right side of the expression.
+  def on_opassign(left, oper, right)
+    left.merge(
+      type: :opassign,
+      body: [left, oper, right],
+      end: right[:end],
+      char_end: right[:char_end]
+    )
+  end
+
+  # params is a parser event that represents defining parameters on a
+  # method. They have a somewhat interesting structure in that they are an
+  # array of arrays where the position in the top-level array indicates the
+  # type of param and the subarray is the list of parameters of that type.
+  # We therefore have to flatten them down to get to the location.
+  def on_params(*types)
+    flattened = types.flatten(2).select { |type| type.is_a?(Hash) }
+    location =
+      if flattened.any?
+        {
+          start: flattened[0][:start],
+          char_start: flattened[0][:char_start],
+          end: flattened[-1][:end],
+          char_end: flattened[-1][:char_end]
+        }
+      else
+        { start: lineno, char_start: char_pos, end: lineno, char_end: char_pos }
+      end
+
+    location.merge!(type: :params, body: types)
+  end
+
+  # A paren is a parser event that represents using parentheses pretty much
+  # anywhere in a Ruby program. It accepts as arguments the contents, which
+  # can be either params or statements.
+  def on_paren(contents)
+    ending = find_scanner_event(:@rparen)
+
+    find_scanner_event(:@lparen).merge!(
+      type: :paren,
+      body: [contents],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    )
+  end
+
+  # 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
+  # some found at the end of the source string.
+  def on_program(stmts)
+    range = {
+      start: 1,
+      end: lines.length,
+      char_start: 0,
+      char_end: source.length
+    }
+
+    stmts[:body] << @__end__ if @__end__
+    stmts.bind(0, source.length)
+
+    range.merge(type: :program, body: [stmts], comments: @comments)
+  end
+
+  # qsymbols_new is a parser event that represents the beginning of a symbol
+  # literal array, like %i[one two three]. It can be followed by any number
+  # of qsymbols_add events, which we'll append onto an array body.
+  def on_qsymbols_new
+    find_scanner_event(:@qsymbols_beg).merge!(type: :qsymbols, body: [])
+  end
+
+  # qsymbols_add is a parser event that represents an element inside of a
+  # symbol literal array like %i[one two three]. It accepts as arguments the
+  # parent qsymbols node as well as a tstring_content scanner event
+  # representing the bare words.
+  def on_qsymbols_add(qsymbols, tstring_content)
+    qsymbols.merge!(
+      body: qsymbols[:body] << tstring_content,
+      end: tstring_content[:end],
+      char_end: tstring_content[:char_end]
+    )
+  end
+
+  # qwords_new is a parser event that represents the beginning of a string
+  # literal array, like %w[one two three]. It can be followed by any number
+  # of qwords_add events, which we'll append onto an array body.
+  def on_qwords_new
+    find_scanner_event(:@qwords_beg).merge!(type: :qwords, body: [])
+  end
+
+  # qsymbols_add is a parser event that represents an element inside of a
+  # symbol literal array like %i[one two three]. It accepts as arguments the
+  # parent qsymbols node as well as a tstring_content scanner event
+  # representing the bare words.
+  def on_qwords_add(qwords, tstring_content)
+    qwords.merge!(
+      body: qwords[:body] << tstring_content,
+      end: tstring_content[:end],
+      char_end: tstring_content[:char_end]
+    )
+  end
+
+  # redo is a parser event that represents the bare redo keyword. It has no
+  # body as it accepts no arguments.
+  def on_redo
+    find_scanner_event(:@kw, 'redo').merge!(type: :redo)
+  end
+
+  # regexp_new is a parser event that represents the beginning of a regular
+  # expression literal, like /foo/. It can be followed by any number of
+  # regexp_add events, which we'll append onto an array body.
+  def on_regexp_new
+    find_scanner_event(:@regexp_beg).merge!(type: :regexp, body: [])
+  end
+
+  # regexp_add is a parser event that represents a piece of a regular
+  # body. It accepts as arguments the parent regexp node as well as a
+  # tstring_content scanner event representing string content or a
+  # string_embexpr parser event representing interpolated content.
+  def on_regexp_add(regexp, piece)
+    regexp.merge!(
+      body: regexp[:body] << piece,
+      end: regexp[:end],
+      char_end: regexp[:char_end]
+    )
+  end
+
+  # regexp_literal is a parser event that represents a regular expression.
+  # It accepts as arguments a regexp node which is a built-up array of
+  # pieces that go into the regexp content, as well as the ending used to
+  # close out the regexp which includes any modifiers.
+  def on_regexp_literal(regexp, ending)
+    regexp.merge!(
+      type: :regexp_literal,
+      ending: ending[:body],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    )
+  end
+
+  # rescue is a special kind of node where you have a rescue chain but it
+  # doesn't really have all of the information that it needs in order to
+  # determine its ending. Therefore it relies on its parent bodystmt node to
+  # report its ending to it.
+  class Rescue < SimpleDelegator
+    def bind_end(char_end)
+      merge!(char_end: char_end)
+
+      stmts = self[:body][2]
+      consequent = self[:body][3]
+
+      if consequent
+        consequent.bind_end(char_end)
+        stmts.bind_end(consequent[:char_start])
+      else
+        stmts.bind_end(char_end)
+      end
+    end
+  end
+
+  # rescue is a parser event that represents the use of the rescue keyword
+  # inside of a bodystmt.
+  def on_rescue(exceptions, variable, stmts, consequent)
+    beging = find_scanner_event(:@kw, 'rescue')
+
+    last_exception = exceptions.is_a?(Array) ? exceptions[-1] : exceptions
+    last_node = variable || last_exception || beging
+
+    stmts.bind(find_next_statement_start(last_node[:char_end]), char_pos)
+
+    Rescue.new(
+      beging.merge!(
+        type: :rescue,
+        body: [exceptions, variable, stmts, consequent],
+        end: lineno,
+        char_end: char_pos
+      )
+    )
+  end
+
+  # rescue_mod represents the modifier form of a rescue clause. It accepts as
+  # arguments the statement that may raise an error and the value that should
+  # be used if it does.
+  def on_rescue_mod(statement, rescued)
+    find_scanner_event(:@kw, 'rescue')
+
+    {
+      type: :rescue_mod,
+      body: [statement, rescued],
+      start: statement[:start],
+      char_start: statement[:char_start],
+      end: rescued[:end],
+      char_end: rescued[:char_end]
+    }
+  end
+
+  # rest_param is a parser event that represents defining a parameter in a
+  # method definition that accepts all remaining positional parameters. It
+  # accepts as an argument an optional identifier for the parameter. If it
+  # is omitted, then we're just using the plain operator.
+  def on_rest_param(ident)
+    oper = find_scanner_event(:@op, '*')
+    return oper.merge!(type: :rest_param, body: [nil]) unless ident
+
+    oper.merge!(
+      type: :rest_param,
+      body: [ident],
+      end: ident[:end],
+      char_end: ident[:char_end]
+    )
+  end
+
+  # retry is a parser event that represents the bare retry keyword. It has
+  # no body as it accepts no arguments.
+  def on_retry
+    find_scanner_event(:@kw, 'retry').merge!(type: :retry)
+  end
+
+  # return is a parser event that represents using the return keyword with
+  # arguments. It accepts as an argument an args_add_block event that
+  # contains all of the arguments being passed.
+  def on_return(args_add_block)
+    find_scanner_event(:@kw, 'return').merge!(
+      type: :return,
+      body: [args_add_block],
+      end: args_add_block[:end],
+      char_end: args_add_block[:char_end]
+    )
+  end
+
+  # return0 is a parser event that represents the bare return keyword. It
+  # has no body as it accepts no arguments. This is as opposed to the return
+  # parser event, which is the version where you're returning one or more
+  # values.
+  def on_return0
+    find_scanner_event(:@kw, 'return').merge!(type: :return0)
+  end
+
+  # sclass is a parser event that represents a block of statements that
+  # should be evaluated within the context of the singleton class of an
+  # object. It's frequently used to define singleton methods. It looks like
+  # the following example:
+  #
+  #     class << self do foo end
+  #               │       │
+  #               │       └> bodystmt
+  #               └> target
+  #
+  def on_sclass(target, bodystmt)
+    beging = find_scanner_event(:@kw, 'class')
+    ending = find_scanner_event(:@kw, 'end')
+
+    bodystmt.bind(
+      find_next_statement_start(target[:char_end]),
+      ending[:char_start]
+    )
+
+    {
+      type: :sclass,
+      body: [target, bodystmt],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # Everything that has a block of code inside of it has a list of statements.
+  # Normally we would just track those as a node that has an array body, but we
+  # have some special handling in order to handle empty statement lists. They
+  # need to have the right location information, so all of the parent node of
+  # stmts nodes will report back down the location information. We then
+  # propagate that onto void_stmt nodes inside the stmts in order to make sure
+  # all comments get printed appropriately.
+  class Stmts < SimpleDelegator
+    def bind(char_start, char_end)
+      merge!(char_start: char_start, char_end: char_end)
+
+      if self[:body][0][:type] == :void_stmt
+        self[:body][0].merge!(char_start: char_start, char_end: char_start)
+      end
+    end
+
+    def bind_end(char_end)
+      merge!(char_end: char_end)
+    end
+
+    def <<(statement)
+      if self[:body].any?
+        merge!(statement.slice(:end, :char_end))
+      else
+        merge!(statement.slice(:start, :end, :char_start, :char_end))
+      end
+
+      self[:body] << statement
+      self
+    end
+  end
+
+  # stmts_new is a parser event that represents the beginning of a list of
+  # statements within any lexical block. It can be followed by any number of
+  # stmts_add events, which we'll append onto an array body.
+  def on_stmts_new
+    Stmts.new(
+      type: :stmts,
+      body: [],
+      start: lineno,
+      end: lineno,
+      char_start: char_pos,
+      char_end: char_pos
+    )
+  end
+
+  # stmts_add is a parser event that represents a single statement inside a
+  # list of statements within any lexical block. It accepts as arguments the
+  # parent stmts node as well as an stmt which can be any expression in
+  # Ruby.
+  def on_stmts_add(stmts, stmt)
+    stmts << stmt
+  end
+
+  # string_concat is a parser event that represents concatenating two
+  # strings together using a backward slash, as in the following example:
+  #
+  #     'foo' \
+  #       'bar'
+  #
+  def on_string_concat(left, right)
+    {
+      type: :string_concat,
+      body: [left, right],
+      start: left[:start],
+      char_start: left[:char_start],
+      end: right[:end],
+      char_end: right[:char_end]
+    }
+  end
+
+  # string_content is a parser event that represents the beginning of the
+  # contents of a string, which will either be embedded inside of a
+  # string_literal or a dyna_symbol node. It will have an array body so that
+  # we can build up a list of @tstring_content, string_embexpr, and
+  # string_dvar nodes.
+  def on_string_content
+    {
+      type: :string,
+      body: [],
+      start: lineno,
+      end: lineno,
+      char_start: char_pos,
+      char_end: char_pos
+    }
+  end
+
+  # string_add is a parser event that represents a piece of a string. It
+  # could be plain @tstring_content, string_embexpr, or string_dvar nodes.
+  # It accepts as arguments the parent string node as well as the additional
+  # piece of the string.
+  def on_string_add(string, piece)
+    string.merge!(
+      body: string[:body] << piece, end: piece[:end], char_end: piece[:char_end]
+    )
+  end
+
+  # string_dvar is a parser event that represents a very special kind of
+  # interpolation into string. It allows you to take an instance variable,
+  # class variable, or global variable and omit the braces when
+  # interpolating. For example, if you wanted to interpolate the instance
+  # variable @foo into a string, you could do "#@foo".
+  def on_string_dvar(var_ref)
+    find_scanner_event(:@embvar).merge!(
+      type: :string_dvar,
+      body: [var_ref],
+      end: var_ref[:end],
+      char_end: var_ref[:char_end]
+    )
+  end
+
+  # string_embexpr is a parser event that represents interpolated content.
+  # It can go a bunch of different parent nodes, including regexp, strings,
+  # xstrings, heredocs, dyna_symbols, etc. Basically it's anywhere you see
+  # the #{} construct.
+  def on_string_embexpr(stmts)
+    beging = find_scanner_event(:@embexpr_beg)
+    ending = find_scanner_event(:@embexpr_end)
+
+    stmts.bind(beging[:char_end], ending[:char_start])
+
+    {
+      type: :string_embexpr,
+      body: [stmts],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # String literals are either going to be a normal string or they're going
+  # to be a heredoc if we've just closed a heredoc.
+  def on_string_literal(string)
+    heredoc = @heredocs[-1]
+
+    if heredoc && heredoc[:ending]
+      @heredocs.pop.merge!(body: string[:body])
+    else
+      beging = find_scanner_event(:@tstring_beg)
+      ending = find_scanner_event(:@tstring_end)
+
+      {
+        type: :string_literal,
+        body: string[:body],
+        quote: beging[:body],
+        start: beging[:start],
+        char_start: beging[:char_start],
+        end: ending[:end],
+        char_end: ending[:char_end]
+      }
+    end
+  end
+
+  # A super is a parser event that represents using the super keyword with
+  # any number of arguments. It can optionally use parentheses (represented
+  # by an arg_paren node) or just skip straight to the arguments (with an
+  # args_add_block node).
+  def on_super(contents)
+    find_scanner_event(:@kw, 'super').merge!(
+      type: :super,
+      body: [contents],
+      end: contents[:end],
+      char_end: contents[:char_end]
+    )
+  end
+
+  # A symbol is a parser event that immediately descends from a symbol
+  # literal and contains an ident representing the contents of the symbol.
+  def on_symbol(ident)
+    # What the heck is this here for you ask!? Turns out when Ripper is lexing
+    # source text, it turns symbols into keywords if their contents match, which
+    # will mess up the location information of all of our other nodes.
+    #
+    # So for example instead of { type: :@ident, body: "class" } you would
+    # instead get { type: :@kw, body: "class" } which is all kinds of
+    # problematic.
+    #
+    # In order to take care of this, we explicitly delete this scanner event
+    # from the stack to make sure it doesn't screw things up.
+    scanner_events.pop
+
+    ident.merge(type: :symbol, body: [ident])
+  end
+
+  # A symbol_literal represents a symbol in the system with no interpolation
+  # (as opposed to a dyna_symbol). As its only argument it accepts either a
+  # symbol node (for most cases) or an ident node (in the case that we're
+  # using bare words, as in an alias node like alias foo bar).
+  def on_symbol_literal(contents)
+    if scanner_events[-1] == contents
+      contents.merge(type: :symbol_literal, body: [contents])
+    else
+      beging = find_scanner_event(:@symbeg)
+      contents.merge!(type: :symbol_literal, char_start: beging[:char_start])
+    end
+  end
+
+  # symbols_new is a parser event that represents the beginning of a symbol
+  # literal array that accepts interpolation, like %I[one #{two} three]. It
+  # can be followed by any number of symbols_add events, which we'll append
+  # onto an array body.
+  def on_symbols_new
+    find_scanner_event(:@symbols_beg).merge!(type: :symbols, body: [])
+  end
+
+  # symbols_add is a parser event that represents an element inside of a
+  # symbol literal array that accepts interpolation, like
+  # %I[one #{two} three]. It accepts as arguments the parent symbols node as
+  # well as a word_add parser event.
+  def on_symbols_add(symbols, word_add)
+    symbols.merge!(
+      body: symbols[:body] << word_add,
+      end: word_add[:end],
+      char_end: word_add[:char_end]
+    )
+  end
+
+  # A helper function to find a :: operator for the next two nodes. We do
+  # special handling instead of using find_scanner_event here because we
+  # don't pop off all of the :: operators so you could end up getting the
+  # wrong information if you have for instance ::X::Y::Z.
+  def find_colon2_before(const)
+    index =
+      scanner_events.rindex do |event|
+        event[:type] == :@op && event[:body] == '::' &&
+          event[:char_start] < const[:char_start]
+      end
+
+    scanner_events[index]
+  end
+
+  # A top_const_field is a parser event that is always the child of some
+  # kind of assignment. It represents when you're assigning to a constant
+  # that is being referenced at the top level. For example:
+  #
+  #     ::X = 1
+  #
+  def on_top_const_field(const)
+    beging = find_colon2_before(const)
+    const.merge(
+      type: :top_const_field,
+      body: [const],
+      start: beging[:start],
+      char_start: beging[:char_start]
+    )
+  end
+
+  # A top_const_ref is a parser event that is a very similar to
+  # top_const_field except that it is not involved in an assignment. It
+  # looks like the following example:
+  #
+  #     ::X
+  #
+  def on_top_const_ref(const)
+    beging = find_colon2_before(const)
+    const.merge(
+      type: :top_const_ref,
+      body: [const],
+      start: beging[:start],
+      char_start: beging[:char_start]
+    )
+  end
+
+  # A unary node represents a unary method being called on an expression, as
+  # in !, ~, or not. We have somewhat special handling of the not operator
+  # since if it has parentheses they don't get reported as a paren node for
+  # some reason.
+  def on_unary(oper, value)
+    if oper == :not
+      node = find_scanner_event(:@kw, 'not')
+
+      paren = source[node[:char_end]...value[:char_start]].include?('(')
+      ending = paren ? find_scanner_event(:@rparen) : value
+
+      node.merge!(
+        type: :unary,
+        oper: oper,
+        body: [value],
+        end: ending[:end],
+        char_end: ending[:char_end],
+        paren: paren
+      )
+    else
+      # Special case instead of using find_scanner_event here. It turns out that
+      # if you have a range that goes from a negative number to a negative
+      # number then you can end up with a .. or a ... that's higher in the
+      # stack. So we need to explicitly disallow those operators.
+      index =
+        scanner_events.rindex do |scanner_event|
+          scanner_event[:type] == :@op &&
+            !%w[.. ...].include?(scanner_event[:body])
+        end
+
+      beging = scanner_events.delete_at(index)
+      beging.merge!(
+        type: :unary,
+        oper: oper[0],
+        body: [value],
+        end: value[:end],
+        char_end: value[:char_end]
+      )
+    end
+  end
+
+  # undef nodes represent using the keyword undef. It accepts as an argument
+  # an array of symbol_literal nodes that represent each message that the
+  # user is attempting to undefine. We use the keyword to get the beginning
+  # location and the last symbol to get the ending.
+  def on_undef(symbol_literals)
+    last = symbol_literals.last
+
+    find_scanner_event(:@kw, 'undef').merge!(
+      type: :undef,
+      body: symbol_literals,
+      end: last[:end],
+      char_end: last[:char_end]
+    )
+  end
+
+  # unless is a parser event that represents the first clause in an unless
+  # chain. It accepts as arguments the predicate of the unless, the
+  # statements that are contained within the unless clause, and the optional
+  # consequent clause.
+  def on_unless(predicate, stmts, consequent)
+    beging = find_scanner_event(:@kw, 'unless')
+    ending = consequent || find_scanner_event(:@kw, 'end')
+
+    stmts.bind(predicate[:char_end], ending[:char_start])
+
+    {
+      type: :unless,
+      body: [predicate, stmts, consequent],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # unless_mod is a parser event that represents the modifier form of an
+  # unless statement. It accepts as arguments the predicate of the unless
+  # and the statement that are contained within the unless clause.
+  def on_unless_mod(predicate, statement)
+    find_scanner_event(:@kw, 'unless')
+
+    {
+      type: :unless_mod,
+      body: [predicate, statement],
+      start: statement[:start],
+      char_start: statement[:char_start],
+      end: predicate[:end],
+      char_end: predicate[:char_end]
+    }
+  end
+
+  # until is a parser event that represents an until loop. It accepts as
+  # arguments the predicate to the until and the statements that are
+  # contained within the until clause.
+  def on_until(predicate, stmts)
+    beging = find_scanner_event(:@kw, 'until')
+    ending = find_scanner_event(:@kw, 'end')
+
+    stmts.bind(predicate[:char_end], ending[:char_start])
+
+    {
+      type: :until,
+      body: [predicate, stmts],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # until_mod is a parser event that represents the modifier form of an
+  # until loop. It accepts as arguments the predicate to the until and the
+  # statement that is contained within the until loop.
+  def on_until_mod(predicate, statement)
+    find_scanner_event(:@kw, 'until')
+
+    {
+      type: :until_mod,
+      body: [predicate, statement],
+      start: statement[:start],
+      char_start: statement[:char_start],
+      end: predicate[:end],
+      char_end: predicate[:char_end]
+    }
+  end
+
+  # var_alias is a parser event that represents when you're using the alias
+  # keyword with global variable arguments. You can optionally use
+  # parentheses with this keyword, so we either track the location
+  # information based on those or the final argument to the alias method.
+  def on_var_alias(left, right)
+    beging = find_scanner_event(:@kw, 'alias')
+
+    paren = source[beging[:char_end]...left[:char_start]].include?('(')
+    ending = paren ? find_scanner_event(:@rparen) : right
+
+    {
+      type: :var_alias,
+      body: [left, right],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # var_ref is a parser event that represents using either a local variable,
+  # a nil literal, a true or false literal, or a numbered block variable.
+  def on_var_ref(contents)
+    contents.merge(type: :var_ref, body: [contents])
+  end
+
+  # var_field is a parser event that represents a variable that is being
+  # assigned a value. As such, it is always a child of an assignment type
+  # node. For example, in the following example foo is a var_field:
+  #
+  #     foo = 1
+  #
+  def on_var_field(ident)
+    if ident
+      ident.merge(type: :var_field, body: [ident])
+    else
+      # You can hit this pattern if you're assigning to a splat using pattern
+      # matching syntax in Ruby 2.7+
+      { type: :var_field, body: [] }
+    end
+  end
+
+  # vcall nodes are any plain named thing with Ruby that could be either a
+  # local variable or a method call. They accept as an argument the ident
+  # scanner event that contains their content.
+  #
+  # Access controls like private, protected, and public are reported as
+  # vcall nodes since they're technically method calls. We want to be able
+  # add new lines around them as necessary, so here we're going to
+  # explicitly track those as a different node type.
+  def on_vcall(ident)
+    @controls ||= %w[private protected public].freeze
+
+    body = ident[:body]
+    type =
+      if @controls.include?(body) && body == lines[lineno - 1].strip
+        :access_ctrl
+      else
+        :vcall
+      end
+
+    ident.merge(type: type, body: [ident])
+  end
+
+  # void_stmt is a special kind of parser event that represents an empty lexical
+  # block of code. It often will have comments attached to it, so it requires
+  # some special handling.
+  def on_void_stmt
+    {
+      type: :void_stmt,
+      start: lineno,
+      end: lineno,
+      char_start: char_pos,
+      char_end: char_pos
+    }
+  end
+
+  # when is a parser event that represents another clause in a case chain.
+  # It accepts as arguments the predicate of the when, the statements that
+  # are contained within the else if clause, and the optional consequent
+  # clause.
+  def on_when(predicate, stmts, consequent)
+    beging = find_scanner_event(:@kw, 'when')
+    ending = consequent || find_scanner_event(:@kw, 'end')
+
+    stmts.bind(predicate[:char_end], ending[:char_start])
+
+    {
+      type: :when,
+      body: [predicate, stmts, consequent],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # while is a parser event that represents a while loop. It accepts as
+  # arguments the predicate to the while and the statements that are
+  # contained within the while clause.
+  def on_while(predicate, stmts)
+    beging = find_scanner_event(:@kw, 'while')
+    ending = find_scanner_event(:@kw, 'end')
+
+    stmts.bind(predicate[:char_end], ending[:char_start])
+
+    {
+      type: :while,
+      body: [predicate, stmts],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
+  # while_mod is a parser event that represents the modifier form of an
+  # while loop. It accepts as arguments the predicate to the while and the
+  # statement that is contained within the while loop.
+  def on_while_mod(predicate, statement)
+    find_scanner_event(:@kw, 'while')
+
+    {
+      type: :while_mod,
+      body: [predicate, statement],
+      start: statement[:start],
+      char_start: statement[:char_start],
+      end: predicate[:end],
+      char_end: predicate[:char_end]
+    }
+  end
+
+  # word_new is a parser event that represents the beginning of a word
+  # within a special array literal (either strings or symbols) that accepts
+  # interpolation. For example, in the following array, there are three
+  # word nodes:
+  #
+  #     %W[one a#{two}a three]
+  #
+  # Each word inside that array is represented as its own node, which is in
+  # terms of the parser a tree of word_new and word_add nodes. For our
+  # purposes, we're going to report this as a word node and build up an
+  # array body of our parts.
+  def on_word_new
+    { type: :word, body: [] }
+  end
+
+  # word_add is a parser event that represents a piece of a word within a
+  # special array literal that accepts interpolation. It accepts as
+  # arguments the parent word node as well as the additional piece of the
+  # word, which can be either a @tstring_content node for a plain string
+  # piece or a string_embexpr for an interpolated piece.
+  def on_word_add(word, piece)
+    if word[:body].empty?
+      # Here we're making sure we get the correct bounds by using the
+      # location information from the first piece.
+      piece.merge(type: :word, body: [piece])
+    else
+      word.merge!(
+        body: word[:body] << piece, end: piece[:end], char_end: piece[:char_end]
+      )
+    end
+  end
+
+  # words_new is a parser event that represents the beginning of a string
+  # literal array that accepts interpolation, like %W[one #{two} three]. It
+  # can be followed by any number of words_add events, which we'll append
+  # onto an array body.
+  def on_words_new
+    find_scanner_event(:@words_beg).merge!(type: :words, body: [])
+  end
+
+  # words_add is a parser event that represents an element inside of a
+  # string literal array that accepts interpolation, like
+  # %W[one #{two} three]. It accepts as arguments the parent words node as
+  # well as a word_add parser event.
+  def on_words_add(words, word_add)
+    words.merge!(
+      body: words[:body] << word_add,
+      end: word_add[:end],
+      char_end: word_add[:char_end]
+    )
+  end
+
+  # xstring_new is a parser event that represents the beginning of a string
+  # of commands that gets sent out to the terminal, like `ls`. It can
+  # optionally include interpolation much like a regular string, so we're
+  # going to build up an array body.
+  #
+  # If the xstring actually starts with a heredoc declaration, then we're
+  # going to let heredocs continue to do their thing and instead just use
+  # its location information.
+  def on_xstring_new
+    heredoc = @heredocs[-1]
+
+    if heredoc && heredoc[:beging][3] = '`'
+      heredoc.merge(type: :xstring, body: [])
+    elsif RUBY_MAJOR <= 2 && RUBY_MINOR <= 5 && RUBY_PATCH < 7
+      { type: :xstring, body: [] }
+    else
+      find_scanner_event(:@backtick).merge!(type: :xstring, body: [])
+    end
+  end
+
+  # xstring_add is a parser event that represents a piece of a string of
+  # commands that gets sent out to the terminal, like `ls`. It accepts two
+  # arguments, the parent xstring node as well as the piece that is being
+  # added to the string. Because it supports interpolation this is either a
+  # tstring_content scanner event representing bare string content or a
+  # string_embexpr representing interpolated content.
+  def on_xstring_add(xstring, piece)
+    xstring.merge!(
+      body: xstring[:body] << piece,
+      end: piece[:end],
+      char_end: piece[:char_end]
+    )
+  end
+
+  # xstring_literal is a parser event that represents a string of commands
+  # that gets sent to the terminal, like `ls`. It accepts as its only
+  # argument an xstring node that is a built up array representation of all
+  # of the parts of the string (including the plain string content and the
+  # interpolated content).
+  #
+  # They can also use heredocs to present themselves, as in the example:
+  #
+  #     <<-`SHELL`
+  #       ls
+  #     SHELL
+  #
+  # In this case we need to change the node type to be a heredoc instead of
+  # an xstring_literal in order to get the right formatting.
+  def on_xstring_literal(xstring)
+    heredoc = @heredocs[-1]
+
+    if heredoc && heredoc[:beging][3] = '`'
+      heredoc.merge!(body: xstring[:body])
+    else
+      ending = find_scanner_event(:@tstring_end)
+      xstring.merge!(
+        type: :xstring_literal, end: ending[:end], char_end: ending[:char_end]
+      )
+    end
+  end
+
+  # yield is a parser event that represents using the yield keyword with
+  # arguments. It accepts as an argument an args_add_block event that
+  # contains all of the arguments being passed.
+  def on_yield(args_add_block)
+    find_scanner_event(:@kw, 'yield').merge!(
+      type: :yield,
+      body: [args_add_block],
+      end: args_add_block[:end],
+      char_end: args_add_block[:char_end]
+    )
+  end
+
+  # yield0 is a parser event that represents the bare yield keyword. It has
+  # no body as it accepts no arguments. This is as opposed to the yield
+  # parser event, which is the version where you're yielding one or more
+  # values.
+  def on_yield0
+    find_scanner_event(:@kw, 'yield').merge!(type: :yield0)
+  end
+
+  # zsuper is a parser event that represents the bare super keyword. It has
+  # no body as it accepts no arguments. This is as opposed to the super
+  # parser event, which is the version where you're calling super with one
+  # or more values.
+  def on_zsuper
+    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