prettier 0.21.0 → 1.0.1

data/src/parser.js

@@ -0,0 +1,86 @@
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+// In order to properly parse ruby code, we need to tell the ruby process to
+// parse using UTF-8. Unfortunately, the way that you accomplish this looks
+// differently depending on your platform.
+const LANG = (() => {
+  const { env, platform } = process;
+  const envValue = env.LC_ALL || env.LC_CTYPE || env.LANG;
+
+  // If an env var is set for the locale that already includes UTF-8 in the
+  // name, then assume we can go with that.
+  if (envValue && envValue.includes("UTF-8")) {
+    return envValue;
+  }
+
+  // Otherwise, we're going to guess which encoding to use based on the system.
+  // This is probably not the best approach in the world, as you could be on
+  // linux and not have C.UTF-8, but in that case you're probably passing an env
+  // var for it. This object below represents all of the possible values of
+  // process.platform per:
+  // https://nodejs.org/api/process.html#process_process_platform
+  return {
+    aix: "C.UTF-8",
+    darwin: "en_US.UTF-8",
+    freebsd: "C.UTF-8",
+    linux: "C.UTF-8",
+    openbsd: "C.UTF-8",
+    sunos: "C.UTF-8",
+    win32: ".UTF-8"
+  }[platform];
+})();
+
+// 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

@@ -2,9 +2,9 @@
 
 # We implement our own version checking here instead of using Gem::Version so
 # that we can use the --disable-gems flag.
-major, minor, * = RUBY_VERSION.split('.').map(&:to_i)
+RUBY_MAJOR, RUBY_MINOR, RUBY_PATCH, * = RUBY_VERSION.split('.').map(&:to_i)
 
-if (major < 2) || ((major == 2) && (minor < 5))
+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.'
@@ -13,761 +13,2540 @@ if (major < 2) || ((major == 2) && (minor < 5))
   exit 1
 end
 
+require 'delegate'
 require 'json' unless defined?(JSON)
 require 'ripper'
 
 module Prettier; end
 
 class Prettier::Parser < Ripper
-  attr_reader :source, :lines, :__end__
+  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.
-  SCANNER_EVENTS.each do |event|
-    define_method(:"on_#{event}") do |body|
-      { type: :"@#{event}", body: body, start: lineno, end: lineno }
+  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
 
-  # Parser events represent nodes in the ripper abstract syntax tree. The event
-  # is reported after the children of the node have already been built.
-  PARSER_EVENTS.each do |event|
-    define_method(:"on_#{event}") do |*body|
-      min = body.map { |part| part.is_a?(Hash) ? part[:start] : lineno }.min
-      { type: event, body: body, start: min || lineno, end: lineno }
-    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
 
-  # Some nodes are lists that come back from the parser. They always start with
-  # a `*_new` node (or in the case of string, `*_content`) and each additional
-  # node in the list is a `*_add` node. This module takes those nodes and turns
-  # them into one node with an array body.
-  #
-  # For example, the statement `[a, b, c]` would be parsed as:
-  #
-  # [:args_add,
-  #   [:args_add,
-  #     [:args_add,
-  #       [:args_new],
-  #       [:vcall, [:@ident, "a", [1, 1]]]
-  #     ],
-  #     [:vcall, [:@ident, "b", [1, 4]]]
-  #   ],
-  #   [:vcall, [:@ident, "c", [1, 7]]]
-  # ]
-  #
-  # But after this module is applied that is instead parsed as:
-  #
-  # [:args,
-  #   [
-  #     [:vcall, [:@ident, "a", [1, 1]]],
-  #     [:vcall, [:@ident, "b", [1, 4]]],
-  #     [:vcall, [:@ident, "c", [1, 7]]]
-  #   ]
-  # ]
-  #
-  # This makes it a lot easier to join things with commas, and ends up resulting
-  # in a much flatter `prettier` tree once it has been converted. Note that
-  # because of this module some extra node types are added (the aggregate of
-  # the previous `*_add` nodes) and some nodes now have arrays in places where
-  # they previously had single nodes.
   prepend(
     Module.new do
-      events = %i[
-        args
-        mlhs
-        mrhs
-        qsymbols
-        qwords
-        regexp
-        stmts
-        string
-        symbols
-        words
-        xstring
-      ]
-
       private
 
-      events.each do |event|
-        suffix = event == :string ? 'content' : 'new'
+      # 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
 
-        define_method(:"on_#{event}_#{suffix}") do
-          { type: event, body: [], start: lineno, end: lineno }
-        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
 
-        define_method(:"on_#{event}_add") do |parts, part|
-          parts.tap do |node|
-            node[:body] << part
-            node[:end] = lineno
-          end
-        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
   )
 
-  # For each node, we need to attach where it came from in order to be able to
-  # support placing the cursor correctly before and after formatting.
+  # 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:
   #
-  # For most nodes, it's enough to look at the child nodes to determine the
-  # start of the parent node. However, for some nodes it's necessary to keep
-  # track of the keywords as they come in from the lexer and to modify the start
-  # node once we have it.
-  prepend(
-    Module.new do
-      def initialize(source, *args)
-        super(source, *args)
+  #     BEGIN {
+  #       # execute stuff here
+  #     }
+  #
+  def on_BEGIN(stmts)
+    beging = find_scanner_event(:@lbrace)
+    ending = find_scanner_event(:@rbrace)
 
-        @scanner_events = []
-        @line_counts = [0]
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
 
-        source.lines.each { |line| line_counts << line_counts.last + line.size }
-      end
+    find_scanner_event(:@kw, 'BEGIN').merge!(
+      type: :BEGIN,
+      body: [beging, stmts],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    )
+  end
 
-      def self.prepended(base)
-        base.attr_reader :scanner_events, :line_counts
-      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)
 
-      private
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
 
-      def char_pos
-        line_counts[lineno - 1] + column
-      end
+    find_scanner_event(:@kw, 'END').merge!(
+      type: :END,
+      body: [beging, stmts],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    )
+  end
 
-      def char_start_for(body)
-        children = body.length == 1 && body[0].is_a?(Array) ? body[0] : body
-        char_starts =
-          children.map { |part| part[:char_start] if part.is_a?(Hash) }.compact
+  # 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
 
-        char_starts.min || char_pos
-      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
 
-      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
+  # 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
 
-        scanner_events.delete_at(index)
-      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
 
-      events = {
-        BEGIN: [:@kw, 'BEGIN'],
-        END: [:@kw, 'END'],
-        alias: [:@kw, 'alias'],
-        assoc_splat: [:@op, '**'],
-        arg_paren: :@lparen,
-        args_add_star: [:@op, '*'],
-        args_forward: [:@op, '...'],
-        begin: [:@kw, 'begin'],
-        blockarg: [:@op, '&'],
-        brace_block: :@lbrace,
-        break: [:@kw, 'break'],
-        case: [:@kw, 'case'],
-        class: [:@kw, 'class'],
-        def: [:@kw, 'def'],
-        defined: [:@kw, 'defined?'],
-        defs: [:@kw, 'def'],
-        do_block: [:@kw, 'do'],
-        else: [:@kw, 'else'],
-        elsif: [:@kw, 'elsif'],
-        ensure: [:@kw, 'ensure'],
-        excessed_comma: :@comma,
-        for: [:@kw, 'for'],
-        hash: :@lbrace,
-        if: [:@kw, 'if'],
-        in: [:@kw, 'in'],
-        kwrest_param: [:@op, '**'],
-        lambda: :@tlambda,
-        mlhs_paren: :@lparen,
-        mrhs_add_star: [:@op, '*'],
-        module: [:@kw, 'module'],
-        next: [:@kw, 'next'],
-        paren: :@lparen,
-        qsymbols_new: :@qsymbols_beg,
-        qwords_new: :@qwords_beg,
-        redo: [:@kw, 'redo'],
-        regexp_literal: :@regexp_beg,
-        rescue: [:@kw, 'rescue'],
-        rest_param: [:@op, '*'],
-        retry: [:@kw, 'retry'],
-        return0: [:@kw, 'return'],
-        return: [:@kw, 'return'],
-        sclass: [:@kw, 'class'],
-        string_dvar: :@embvar,
-        string_embexpr: :@embexpr_beg,
-        super: [:@kw, 'super'],
-        symbols_new: :@symbols_beg,
-        top_const_field: [:@op, '::'],
-        top_const_ref: [:@op, '::'],
-        undef: [:@kw, 'undef'],
-        unless: [:@kw, 'unless'],
-        until: [:@kw, 'until'],
-        var_alias: [:@kw, 'alias'],
-        when: [:@kw, 'when'],
-        while: [:@kw, 'while'],
-        words_new: :@words_beg,
-        xstring_literal: :@backtick,
-        yield0: [:@kw, 'yield'],
-        yield: [:@kw, 'yield'],
-        zsuper: [:@kw, 'super']
+  # 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
 
-      events.each do |event, (type, scanned)|
-        define_method(:"on_#{event}") do |*body|
-          node = find_scanner_event(type, scanned || :any)
+  # 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
 
-          super(*body).merge!(
-            start: node[:start],
-            char_start: node[:char_start],
-            char_end: char_pos
-          )
-        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
 
-      # 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.
-      def on_array(*body)
-        if body[0] && %i[args args_add_star].include?(body[0][:type])
-          node = find_scanner_event(:@lbracket)
-
-          super(*body).merge!(
-            start: node[:start],
-            char_start: node[:char_start],
-            char_end: char_pos
-          )
-        else
-          super(*body).merge!(
-            char_start: char_start_for(body), char_end: char_pos
-          )
-        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
 
-      # Array pattern nodes contain an odd mix of potential child nodes based on
-      # which kind of pattern is being used.
-      def on_aryptn(*body)
-        char_start, char_end = char_pos, char_pos
+  # 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
 
-        body.flatten(1).each do |part|
-          next unless part
+  # 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
 
-          char_start = [char_start, part[:char_start]].min
-          char_end = [char_end, part[:char_end]].max
-        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
 
-        super(*body).merge!(char_start: char_start, char_end: char_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
 
-      # Params 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(*body)
-        super(*body).merge!(
-          char_start: char_start_for(body.flatten(1)), char_end: char_pos
-        )
-      end
+    bodystmt.bind(beging[:char_end], char_end)
 
-      # String literals and either contain string parts or a heredoc. If it
-      # contains a heredoc we can just go directly to the child nodes, otherwise
-      # we need to look for a `tstring_beg`.
-      def on_string_literal(*body)
-        if body[0][:type] == :heredoc
-          super(*body).merge!(
-            char_start: char_start_for(body), char_end: char_pos
-          )
-        else
-          node = find_scanner_event(:@tstring_beg)
-
-          super(*body).merge!(
-            start: node[:start],
-            char_start: node[:char_start],
-            char_end: char_pos,
-            quote: node[:body]
-          )
-        end
-      end
+    beging.merge!(
+      type: :begin,
+      body: [bodystmt],
+      end: bodystmt[:end],
+      char_end: bodystmt[:char_end]
+    )
+  end
 
-      # Technically, the `not` operator is a unary operator but is reported as
-      # a keyword and not an operator. Because of the inconsistency, we have to
-      # manually look for the correct scanner event here.
-      def on_unary(*body)
-        node =
-          if body[0] == :not
-            find_scanner_event(:@kw, 'not')
-          else
-            find_scanner_event(:@op)
-          end
-
-        super(*body).merge!(
-          start: node[:start], char_start: node[:char_start], char_end: char_pos
-        )
-      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
 
-      # Symbols don't necessarily have to have a @symbeg event fired before they
-      # start. For example, you can have symbol literals inside an `alias` node
-      # if you're just using bare words, as in: `alias foo bar`. So this is a
-      # special case in which if there is a `:@symbeg` event we can hook on to
-      # then we use it, otherwise we just look at the beginning of the first
-      # child node.
-      %i[dyna_symbol symbol_literal].each do |event|
-        define_method(:"on_#{event}") do |*body|
-          options =
-            if scanner_events.any? { |sevent| sevent[:type] == :@symbeg }
-              symbeg = find_scanner_event(:@symbeg)
-
-              {
-                char_start: symbeg[:char_start],
-                char_end: char_pos,
-                quote: symbeg[:body][1]
-              }
-            elsif scanner_events.any? { |sevent| sevent[:type] == :@label_end }
-              label_end = find_scanner_event(:@label_end)
-
-              {
-                char_start: char_start_for(body),
-                char_end: char_pos,
-                quote: label_end[:body][0]
-              }
-            else
-              { char_start: char_start_for(body), char_end: char_pos }
-            end
-
-          super(*body).merge!(options)
-        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
 
-      def on_program(*body)
-        super(*body).merge!(start: 1, char_start: 0, char_end: char_pos)
+    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
 
-      defined =
-        private_instance_methods(false).grep(/\Aon_/) { $'.to_sym } +
-          %i[embdoc embdoc_beg embdoc_end heredoc_beg heredoc_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
 
-      (SCANNER_EVENTS - defined).each do |event|
-        define_method(:"on_#{event}") do |body|
-          super(body).tap do |node|
-            char_end = char_pos + (body ? body.size : 0)
-            node.merge!(char_start: char_pos, char_end: char_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
 
-            scanner_events << node
-          end
-        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
 
-      (PARSER_EVENTS - defined).each do |event|
-        define_method(:"on_#{event}") do |*body|
-          super(*body).merge!(
-            char_start: char_start_for(body), char_end: char_pos
-          )
-        end
-      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
-  )
 
-  # This layer keeps track of inline comments as they come in. Ripper itself
-  # doesn't attach comments to the AST, so we need to do it manually. In this
-  # case, inline comments are defined as any comments wherein the lexer state is
-  # not equal to EXPR_BEG (tracked in the BlockComments layer).
-  prepend(
-    Module.new do
-      # Certain events needs to steal the comments from their children in order
-      # for them to display properly.
-      events = {
-        aref: [:body, 1],
-        args_add_block: [:body, 0],
-        break: [:body, 0],
-        call: [:body, 0],
-        command: [:body, 1],
-        command_call: [:body, 3],
-        regexp_literal: [:body, 0],
-        string_literal: [:body, 0],
-        symbol_literal: [:body, 0]
-      }
+    {
+      type: :call,
+      body: [receiver, oper, sending],
+      start: receiver[:start],
+      char_start: receiver[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
 
-      def initialize(*args)
-        super(*args)
-        @inline_comments = []
-        @last_sexp = nil
-      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
 
-      def self.prepended(base)
-        base.attr_reader :inline_comments, :last_sexp
-      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]
 
-      private
+    if remaining.sub(/\A +/, '')[0] == '#'
+      return position + remaining.index("\n")
+    end
 
-      events.each do |event, path|
-        define_method(:"on_#{event}") do |*body|
-          @last_sexp =
-            super(*body).tap do |sexp|
-              comments = (sexp.dig(*path) || {}).delete(:comments)
-              sexp.merge!(comments: comments) if comments
-            end
-        end
-      end
+    position
+  end
 
-      SPECIAL_LITERALS = %i[qsymbols qwords symbols words].freeze
+  # 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]
+    )
 
-      # Special array literals are handled in different ways and so their
-      # comments need to be passed up to their parent array node.
-      def on_array(*body)
-        @last_sexp =
-          super(*body).tap do |sexp|
-            next unless SPECIAL_LITERALS.include?(body.dig(0, :type))
+    {
+      type: :class,
+      body: [const, superclass, bodystmt],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
 
-            comments = sexp.dig(:body, 0).delete(:comments)
-            sexp.merge!(comments: comments) if comments
-          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
 
-      # Handling this specially because we want to pull the comments out of both
-      # child nodes.
-      def on_assoc_new(*body)
-        @last_sexp =
-          super(*body).tap do |sexp|
-            comments =
-              (sexp.dig(:body, 0).delete(:comments) || []) +
-                (sexp.dig(:body, 1).delete(:comments) || [])
-
-            sexp.merge!(comments: comments) if comments.any?
-          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
 
-      # Most scanner events don't stand on their own as s-expressions, but the
-      # CHAR scanner event is effectively just a string, so we need to track it
-      # as a s-expression.
-      def on_CHAR(body)
-        @last_sexp = super(body)
-      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
 
-      # We need to know exactly where the comment is, switching off the current
-      # lexer state. In Ruby 2.7.0-dev, that's defined as:
-      #
-      # enum lex_state_bits {
-      #     EXPR_BEG_bit,     /* ignore newline, +/- is a sign. */
-      #     EXPR_END_bit,     /* newline significant, +/- is an operator. */
-      #     EXPR_ENDARG_bit,  /* ditto, and unbound braces. */
-      #     EXPR_ENDFN_bit,   /* ditto, and unbound braces. */
-      #     EXPR_ARG_bit,     /* newline significant, +/- is an operator. */
-      #     EXPR_CMDARG_bit,  /* newline significant, +/- is an operator. */
-      #     EXPR_MID_bit,     /* newline significant, +/- is an operator. */
-      #     EXPR_FNAME_bit,   /* ignore newline, no reserved words. */
-      #     EXPR_DOT_bit,     /* right after `.' or `::', no reserved words. */
-      #     EXPR_CLASS_bit,   /* immediate after `class', no here document. */
-      #     EXPR_LABEL_bit,   /* flag bit, label is allowed. */
-      #     EXPR_LABELED_bit, /* flag bit, just after a label. */
-      #     EXPR_FITEM_bit,   /* symbol literal as FNAME. */
-      #     EXPR_MAX_STATE
-      # };
-      def on_comment(body)
-        sexp = { type: :@comment, body: body.chomp, start: lineno, end: lineno }
-
-        case Prettier::Parser.lex_state_name(state).gsub('EXPR_', '')
-        when 'END', 'ARG|LABELED', 'ENDFN'
-          last_sexp.merge!(comments: [sexp])
-        when 'CMDARG', 'END|ENDARG', 'ENDARG', 'ARG', 'FNAME|FITEM', 'CLASS',
-             'END|LABEL'
-          inline_comments << sexp
-        when 'BEG|LABEL', 'MID'
-          inline_comments << sexp.merge!(break: true)
-        when 'DOT'
-          last_sexp.merge!(comments: [sexp.merge!(break: true)])
-        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
 
-        sexp
-      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
 
-      defined = private_instance_methods(false).grep(/\Aon_/) { $'.to_sym }
+    beging = find_scanner_event(:@kw, 'def')
+    ending = find_scanner_event(:@kw, 'end')
 
-      (PARSER_EVENTS - defined).each do |event|
-        define_method(:"on_#{event}") do |*body|
-          super(*body).tap do |sexp|
-            @last_sexp = sexp
-            next if inline_comments.empty?
+    bodystmt.bind(
+      find_next_statement_start(params[:char_end]),
+      ending[:char_start]
+    )
 
-            sexp[:comments] = inline_comments.reverse
-            @inline_comments = []
-          end
-        end
-      end
+    {
+      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
-  )
 
-  # Nodes that are always on their own line occur when the lexer is in the
-  # EXPR_BEG state. Those comments are tracked within the @block_comments
-  # instance variable. Then for each node that could contain them, we attach
-  # them after the node has been built.
-  prepend(
-    Module.new do
-      events = {
-        begin: [0, :body, 0],
-        bodystmt: [0],
-        class: [2, :body, 0],
-        def: [2, :body, 0],
-        defs: [4, :body, 0],
-        else: [0],
-        elsif: [1],
-        ensure: [0],
-        if: [1],
-        program: [0],
-        rescue: [2],
-        sclass: [1, :body, 0],
-        unless: [1],
-        until: [1],
-        when: [1],
-        while: [1]
-      }
+    beging = find_scanner_event(:@kw, 'def')
+    ending = find_scanner_event(:@kw, 'end')
 
-      def initialize(*args)
-        super(*args)
-        @block_comments = []
-        @current_embdoc = nil
-      end
+    bodystmt.bind(
+      find_next_statement_start(params[:char_end]),
+      ending[:char_start]
+    )
 
-      def self.prepended(base)
-        base.attr_reader :block_comments, :current_embdoc
-      end
+    {
+      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
 
-      private
+  # 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
 
-      def attach_comments(sexp, stmts)
-        range = sexp[:start]..sexp[:end]
-        comments =
-          block_comments.group_by { |comment| range.include?(comment[:start]) }
+  # 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
 
-        if comments[true]
-          stmts[:body] =
-            (stmts[:body] + comments[true]).sort_by { |node| node[:start] }
+  # 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
 
-          @block_comments = comments.fetch(false) { [] }
-        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
 
-      events.each do |event, path|
-        define_method(:"on_#{event}") do |*body|
-          super(*body).tap { |sexp| attach_comments(sexp, body.dig(*path)) }
-        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
 
-      def on_comment(body)
-        super(body).tap do |sexp|
-          lex_state = Prettier::Parser.lex_state_name(state).gsub('EXPR_', '')
-          block_comments << sexp if lex_state == 'BEG'
-        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
 
-      def on_embdoc_beg(comment)
-        @current_embdoc = {
-          type: :embdoc, body: comment, start: lineno, end: lineno
-        }
-      end
+    event = scanner_events[index]
+    event[:body] == 'end' ? scanner_events.delete_at(index) : event
+  end
 
-      def on_embdoc(comment)
-        @current_embdoc[:body] << comment
-      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
 
-      def on_embdoc_end(comment)
-        @current_embdoc[:body] << comment.chomp
-        @block_comments << @current_embdoc
-        @current_embdoc = nil
-      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
 
-      def on_method_add_block(*body)
-        super(*body).tap do |sexp|
-          stmts = body[1][:body][1]
-          stmts = stmts[:type] == :stmts ? stmts : body[1][:body][1][:body][0]
+  # 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
 
-          attach_comments(sexp, stmts)
-        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
-  )
 
-  # Tracking heredocs in somewhat interesting. Straight-line heredocs are
-  # reported as strings, whereas squiggly-line heredocs are reported as
-  # heredocs. We track the start and matching end of the heredoc as "beging" and
-  # "ending" respectively.
-  prepend(
-    Module.new do
-      def initialize(*args)
-        super(*args)
-        @heredoc_stack = []
-      end
+    {
+      type: :hash,
+      body: [assoclist_from_args],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
 
-      def self.prepended(base)
-        base.attr_reader :heredoc_stack
-      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
 
-      private
+  # 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
 
-      # This is a scanner event that represents the beginning of the heredoc.
-      def on_heredoc_beg(beging)
+  # 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?
         {
-          type: :heredoc,
-          beging: beging,
-          start: lineno,
-          end: lineno,
-          char_start: char_pos - beging.length + 1,
-          char_end: char_pos
-        }.tap { |node| heredoc_stack << node }
+          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
 
-      # This is a scanner event that represents the end of the heredoc.
-      def on_heredoc_end(ending)
-        heredoc_stack[-1].merge!(
-          ending: ending.chomp, end: lineno, char_end: char_pos
-        )
-      end
+    location.merge!(type: :params, body: types)
+  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)
-        heredoc_stack[-1].merge!(string.slice(:body))
-      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
 
-      # String literals are either going to be a normal string or they're going
-      # to be a heredoc with a hyphen.
-      def on_string_literal(string)
-        heredoc = heredoc_stack[-1]
+  # 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
 
-        if heredoc && heredoc[:ending]
-          heredoc_stack.pop.merge!(string.slice(:body))
-        else
-          super
-        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
 
-  # This module contains miscellaneous fixes required to get the right
-  # structure.
-  prepend(
-    Module.new do
-      private
+  # 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')
 
-      # These are the event types that contain _actual_ string content. 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.
-      %w[comment ident tstring_content].each do |event|
-        define_method(:"on_#{event}") do |body|
-          super(body.force_encoding('UTF-8'))
-        end
-      end
+    last_exception = exceptions.is_a?(Array) ? exceptions[-1] : exceptions
+    last_node = variable || last_exception || beging
 
-      # 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__(body)
-        @__end__ = super(lines[lineno..-1].join("\n"))
-      end
+    stmts.bind(find_next_statement_start(last_node[:char_end]), char_pos)
 
-      def on_program(*body)
-        super(*body).tap { |node| node[:body][0][:body] << __end__ if __end__ }
-      end
+    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
 
-      # Normally access controls are reported as vcall nodes. This creates a
-      # new node type to explicitly track those nodes instead, so that the
-      # printer can add new lines as necessary.
-      def on_vcall(ident)
-        @access_controls ||= %w[private protected public].freeze
+  # 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
 
-        super(ident).tap do |node|
-          if !@access_controls.include?(ident[:body]) ||
-               ident[:body] != lines[lineno - 1].strip
-            next
-          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
 
-          node.merge!(type: :access_ctrl)
-        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
 
-      # When the only statement inside of a `def` node is a `begin` node, then
-      # you can safely replace the body of the `def` with the body of the
-      # `begin`. For example:
-      #
-      # def foo
-      #   begin
-      #     try_something
-      #   rescue SomeError => error
-      #     handle_error(error)
-      #   end
-      # end
-      #
-      # can get transformed into:
-      #
-      # def foo
-      #   try_something
-      # rescue SomeError => error
-      #   handle_error(error)
-      # end
-      #
-      # This module handles this by hoisting up the `bodystmt` node from the
-      # inner `begin` up to the `def`.
-      def on_def(ident, params, bodystmt)
-        def_bodystmt = bodystmt
-        stmts, *other_parts = bodystmt[:body]
-
-        if !other_parts.any? && stmts[:body].length == 1 &&
-             stmts.dig(:body, 0, :type) == :begin
-          def_bodystmt = stmts.dig(:body, 0, :body, 0)
-        end
+    def bind_end(char_end)
+      merge!(char_end: char_end)
+    end
 
-        super(ident, params, def_bodystmt)
+    def <<(statement)
+      if self[:body].any?
+        merge!(statement.slice(:end, :char_end))
+      else
+        merge!(statement.slice(:start, :end, :char_start, :char_end))
       end
 
-      # We need to track for `mlhs_paren` and `massign` nodes whether or not
-      # there was an extra comma at the end of the expression. For some reason
-      # it's not showing up in the AST in an obvious way. In this case we're
-      # just simplifying everything by adding an additional field to `mlhs`
-      # nodes called `comma` that indicates whether or not there was an extra.
-      def on_mlhs_paren(body)
-        super.tap do |node|
-          next unless body[:type] == :mlhs
+      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
 
-          ending = source.rindex(')', char_pos)
-          buffer = source[(node[:char_start] + 1)...ending]
+  # 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
 
-          body[:comma] = buffer.strip.end_with?(',')
-        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
 
-      def on_massign(left, right)
-        super.tap do
-          next unless left[:type] == :mlhs
+    scanner_events[index]
+  end
 
-          range = left[:char_start]..left[:char_end]
-          left[:comma] = source[range].strip.end_with?(',')
+  # 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 parse.js spawn. In that case, read the ruby source from
+# 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__