diff --git a/Rakefile b/Rakefile
index 22d7d1fe..fb4f8847 100644
--- a/Rakefile
+++ b/Rakefile
@@ -16,7 +16,16 @@ task default: :test
 
 configure = ->(task) do
   task.source_files =
-    FileList[%w[Gemfile Rakefile syntax_tree.gemspec lib/**/*.rb test/*.rb]]
+    FileList[
+      %w[
+        Gemfile
+        Rakefile
+        syntax_tree.gemspec
+        lib/**/*.rb
+        tasks/*.rake
+        test/*.rb
+      ]
+    ]
 
   # Since Syntax Tree supports back to Ruby 2.7.0, we need to make sure that we
   # format our code such that it's compatible with that version. This actually
diff --git a/bin/console b/bin/console
index 1c18bd62..6f35f1ec 100755
--- a/bin/console
+++ b/bin/console
@@ -3,6 +3,7 @@
 
 require "bundler/setup"
 require "syntax_tree"
+require "syntax_tree/reflection"
 
 require "irb"
 IRB.start(__FILE__)
diff --git a/lib/syntax_tree/dsl.rb b/lib/syntax_tree/dsl.rb
index 860a1fe5..1af19644 100644
--- a/lib/syntax_tree/dsl.rb
+++ b/lib/syntax_tree/dsl.rb
@@ -210,12 +210,17 @@ def RAssign(value, operator, pattern)
     end
 
     # Create a new ClassDeclaration node.
-    def ClassDeclaration(constant, superclass, bodystmt)
+    def ClassDeclaration(
+      constant,
+      superclass,
+      bodystmt,
+      location = Location.default
+    )
       ClassDeclaration.new(
         constant: constant,
         superclass: superclass,
         bodystmt: bodystmt,
-        location: Location.default
+        location: location
       )
     end
 
@@ -225,12 +230,12 @@ def Comma(value)
     end
 
     # Create a new Command node.
-    def Command(message, arguments, block)
+    def Command(message, arguments, block, location = Location.default)
       Command.new(
         message: message,
         arguments: arguments,
         block: block,
-        location: Location.default
+        location: location
       )
     end
 
@@ -247,8 +252,8 @@ def CommandCall(receiver, operator, message, arguments, block)
     end
 
     # Create a new Comment node.
-    def Comment(value, inline)
-      Comment.new(value: value, inline: inline, location: Location.default)
+    def Comment(value, inline, location = Location.default)
+      Comment.new(value: value, inline: inline, location: location)
     end
 
     # Create a new Const node.
@@ -285,14 +290,21 @@ def CVar(value)
     end
 
     # Create a new DefNode node.
-    def DefNode(target, operator, name, params, bodystmt)
+    def DefNode(
+      target,
+      operator,
+      name,
+      params,
+      bodystmt,
+      location = Location.default
+    )
       DefNode.new(
         target: target,
         operator: operator,
         name: name,
         params: params,
         bodystmt: bodystmt,
-        location: Location.default
+        location: location
       )
     end
 
@@ -565,8 +577,8 @@ def MAssign(target, value)
     end
 
     # Create a new MethodAddBlock node.
-    def MethodAddBlock(call, block)
-      MethodAddBlock.new(call: call, block: block, location: Location.default)
+    def MethodAddBlock(call, block, location = Location.default)
+      MethodAddBlock.new(call: call, block: block, location: location)
     end
 
     # Create a new MLHS node.
diff --git a/lib/syntax_tree/node.rb b/lib/syntax_tree/node.rb
index 70fbdf4c..4a98dae4 100644
--- a/lib/syntax_tree/node.rb
+++ b/lib/syntax_tree/node.rb
@@ -557,7 +557,7 @@ def var_alias?
   #     collection[]
   #
   class ARef < Node
-    # [untyped] the value being indexed
+    # [Node] the value being indexed
     attr_reader :collection
 
     # [nil | Args] the value being passed within the brackets
@@ -635,7 +635,7 @@ def ===(other)
   #     collection[index] = value
   #
   class ARefField < Node
-    # [untyped] the value being indexed
+    # [Node] the value being indexed
     attr_reader :collection
 
     # [nil | Args] the value being passed within the brackets
@@ -810,7 +810,7 @@ def trailing_comma?
   #     method(first, second, third)
   #
   class Args < Node
-    # [Array[ untyped ]] the arguments that this node wraps
+    # [Array[ Node ]] the arguments that this node wraps
     attr_reader :parts
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -876,7 +876,7 @@ def arity
   #     method(&expression)
   #
   class ArgBlock < Node
-    # [nil | untyped] the expression being turned into a block
+    # [nil | Node] the expression being turned into a block
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -928,7 +928,7 @@ def ===(other)
   #     method(*arguments)
   #
   class ArgStar < Node
-    # [nil | untyped] the expression being splatted
+    # [nil | Node] the expression being splatted
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -1131,7 +1131,8 @@ def format(q)
       end
     end
 
-    # [LBracket] the bracket that opens this array
+    # [nil | LBracket | QSymbolsBeg | QWordsBeg | SymbolsBeg | WordsBeg] the
+    # bracket that opens this array
     attr_reader :lbracket
 
     # [nil | Args] the contents of the array
@@ -1289,7 +1290,7 @@ def format(q)
     # [nil | VarRef] the optional constant wrapper
     attr_reader :constant
 
-    # [Array[ untyped ]] the regular positional arguments that this array
+    # [Array[ Node ]] the regular positional arguments that this array
     # pattern is matching against
     attr_reader :requireds
 
@@ -1297,7 +1298,7 @@ def format(q)
     # positional arguments
     attr_reader :rest
 
-    # [Array[ untyped ]] the list of positional arguments occurring after the
+    # [Array[ Node ]] the list of positional arguments occurring after the
     # optional star if there is one
     attr_reader :posts
 
@@ -1407,7 +1408,7 @@ class Assign < Node
     # to assign the result of the expression to
     attr_reader :target
 
-    # [untyped] the expression to be assigned
+    # [Node] the expression to be assigned
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -1482,10 +1483,10 @@ def skip_indent?
   #
   # In the above example, the would be two Assoc nodes.
   class Assoc < Node
-    # [untyped] the key of this pair
+    # [Node] the key of this pair
     attr_reader :key
 
-    # [untyped] the value of this pair
+    # [nil | Node] the value of this pair
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -1560,7 +1561,7 @@ def format_contents(q)
   #     { **pairs }
   #
   class AssocSplat < Node
-    # [nil | untyped] the expression that is being splatted
+    # [nil | Node] the expression that is being splatted
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -1924,7 +1925,7 @@ def ===(other)
   #     end
   #
   class PinnedBegin < Node
-    # [untyped] the expression being pinned
+    # [Node] the expression being pinned
     attr_reader :statement
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -2005,13 +2006,13 @@ def name
             }
     end
 
-    # [untyped] the left-hand side of the expression
+    # [Node] the left-hand side of the expression
     attr_reader :left
 
     # [Symbol] the operator used between the two expressions
     attr_reader :operator
 
-    # [untyped] the right-hand side of the expression
+    # [Node] the right-hand side of the expression
     attr_reader :right
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -2670,7 +2671,7 @@ def format(q)
   # Of course there are a lot of caveats to that, including trailing operators
   # when necessary, where comments are places, how blocks are aligned, etc.
   class CallChainFormatter
-    # [Call | MethodAddBlock] the top of the call chain
+    # [CallNode | MethodAddBlock] the top of the call chain
     attr_reader :node
 
     def initialize(node)
@@ -2891,7 +2892,7 @@ def format_child(
   #     receiver.message
   #
   class CallNode < Node
-    # [nil | untyped] the receiver of the method call
+    # [nil | Node] the receiver of the method call
     attr_reader :receiver
 
     # [nil | :"::" | Op | Period] the operator being used to send the message
@@ -3067,7 +3068,7 @@ class Case < Node
     # [Kw] the keyword that opens this expression
     attr_reader :keyword
 
-    # [nil | untyped] optional value being switched on
+    # [nil | Node] optional value being switched on
     attr_reader :value
 
     # [In | When] the next clause in the chain
@@ -3146,14 +3147,14 @@ def ===(other)
   #     value => pattern
   #
   class RAssign < Node
-    # [untyped] the left-hand expression
+    # [Node] the left-hand expression
     attr_reader :value
 
     # [Kw | Op] the operator being used to match against the pattern, which is
     # either => or in
     attr_reader :operator
 
-    # [untyped] the pattern on the right-hand side of the expression
+    # [Node] the pattern on the right-hand side of the expression
     attr_reader :pattern
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -3264,7 +3265,7 @@ class ClassDeclaration < Node
     # defined
     attr_reader :constant
 
-    # [nil | untyped] the optional superclass declaration
+    # [nil | Node] the optional superclass declaration
     attr_reader :superclass
 
     # [BodyStmt] the expressions to execute within the context of the class
@@ -3402,7 +3403,7 @@ class Command < Node
     # [Args] the arguments being sent with the message
     attr_reader :arguments
 
-    # [nil | Block] the optional block being passed to the method
+    # [nil | BlockNode] the optional block being passed to the method
     attr_reader :block
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -3508,19 +3509,19 @@ def align(q, node, &block)
   #     object.method argument
   #
   class CommandCall < Node
-    # [untyped] the receiver of the message
+    # [nil | Node] the receiver of the message
     attr_reader :receiver
 
-    # [:"::" | Op | Period] the operator used to send the message
+    # [nil | :"::" | Op | Period] the operator used to send the message
     attr_reader :operator
 
-    # [Const | Ident | Op] the message being send
+    # [:call | Const | Ident | Op] the message being send
     attr_reader :message
 
-    # [nil | Args] the arguments going along with the message
+    # [nil | Args | ArgParen] the arguments going along with the message
     attr_reader :arguments
 
-    # [nil | Block] the block associated with this method call
+    # [nil | BlockNode] the block associated with this method call
     attr_reader :block
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -3806,7 +3807,7 @@ def ===(other)
   #     object::Const = value
   #
   class ConstPathField < Node
-    # [untyped] the source of the constant
+    # [Node] the source of the constant
     attr_reader :parent
 
     # [Const] the constant itself
@@ -3870,7 +3871,7 @@ def ===(other)
   #     object::Const
   #
   class ConstPathRef < Node
-    # [untyped] the source of the constant
+    # [Node] the source of the constant
     attr_reader :parent
 
     # [Const] the constant itself
@@ -4039,7 +4040,7 @@ def ===(other)
   #     def object.method(param) result end
   #
   class DefNode < Node
-    # [nil | untyped] the target where the method is being defined
+    # [nil | Node] the target where the method is being defined
     attr_reader :target
 
     # [nil | Op | Period] the operator being used to declare the method
@@ -4051,7 +4052,7 @@ class DefNode < Node
     # [nil | Params | Paren] the parameter declaration for the method
     attr_reader :params
 
-    # [BodyStmt | untyped] the expressions to be executed by the method
+    # [BodyStmt | Node] the expressions to be executed by the method
     attr_reader :bodystmt
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -4185,7 +4186,7 @@ def arity
   #     defined?(variable)
   #
   class Defined < Node
-    # [untyped] the value being sent to the keyword
+    # [Node] the value being sent to the keyword
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -4476,13 +4477,13 @@ def format_flat(q, flat_opening, flat_closing)
   #
   # One of the sides of the expression may be nil, but not both.
   class RangeNode < Node
-    # [nil | untyped] the left side of the expression
+    # [nil | Node] the left side of the expression
     attr_reader :left
 
     # [Op] the operator used for this range
     attr_reader :operator
 
-    # [nil | untyped] the right side of the expression
+    # [nil | Node] the right side of the expression
     attr_reader :right
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -4603,7 +4604,7 @@ class DynaSymbol < Node
     # dynamic symbol
     attr_reader :parts
 
-    # [String] the quote used to delimit the dynamic symbol
+    # [nil | String] the quote used to delimit the dynamic symbol
     attr_reader :quote
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -4801,7 +4802,7 @@ def ===(other)
   #     end
   #
   class Elsif < Node
-    # [untyped] the expression to be checked
+    # [Node] the expression to be checked
     attr_reader :predicate
 
     # [Statements] the expressions to be executed
@@ -5227,7 +5228,7 @@ def ===(other)
   #     object.variable = value
   #
   class Field < Node
-    # [untyped] the parent object that owns the field being assigned
+    # [Node] the parent object that owns the field being assigned
     attr_reader :parent
 
     # [:"::" | Op | Period] the operator being used for the assignment
@@ -5353,13 +5354,13 @@ def ===(other)
   #     end
   #
   class FndPtn < Node
-    # [nil | untyped] the optional constant wrapper
+    # [nil | Node] the optional constant wrapper
     attr_reader :constant
 
     # [VarField] the splat on the left-hand side
     attr_reader :left
 
-    # [Array[ untyped ]] the list of positional expressions in the pattern that
+    # [Array[ Node ]] the list of positional expressions in the pattern that
     # are being matched
     attr_reader :values
 
@@ -5455,7 +5456,7 @@ class For < Node
     # pull values out of the object being enumerated
     attr_reader :index
 
-    # [untyped] the object being enumerated in the loop
+    # [Node] the object being enumerated in the loop
     attr_reader :collection
 
     # [Statements] the statements to be executed
@@ -5934,7 +5935,7 @@ class KeywordFormatter
       # [Label] the keyword being used
       attr_reader :key
 
-      # [untyped] the optional value for the keyword
+      # [Node] the optional value for the keyword
       attr_reader :value
 
       def initialize(key, value)
@@ -5947,7 +5948,7 @@ def comments
       end
 
       def format(q)
-        q.format(key)
+        HashKeyFormatter::Labels.new.format_key(q, key)
 
         if value
           q.text(" ")
@@ -5975,11 +5976,11 @@ def format(q)
       end
     end
 
-    # [nil | untyped] the optional constant wrapper
+    # [nil | Node] the optional constant wrapper
     attr_reader :constant
 
-    # [Array[ [Label, untyped] ]] the set of tuples representing the keywords
-    # that should be matched against in the pattern
+    # [Array[ [DynaSymbol | Label, nil | Node] ]] the set of tuples
+    # representing the keywords that should be matched against in the pattern
     attr_reader :keywords
 
     # [nil | VarField] an optional parameter to gather up all remaining keywords
@@ -6404,7 +6405,7 @@ def contains_conditional?
   #     end
   #
   class IfNode < Node
-    # [untyped] the expression to be checked
+    # [Node] the expression to be checked
     attr_reader :predicate
 
     # [Statements] the expressions to be executed
@@ -6477,13 +6478,13 @@ def modifier?
   #     predicate ? truthy : falsy
   #
   class IfOp < Node
-    # [untyped] the expression to be checked
+    # [Node] the expression to be checked
     attr_reader :predicate
 
-    # [untyped] the expression to be executed if the predicate is truthy
+    # [Node] the expression to be executed if the predicate is truthy
     attr_reader :truthy
 
-    # [untyped] the expression to be executed if the predicate is falsy
+    # [Node] the expression to be executed if the predicate is falsy
     attr_reader :falsy
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -6667,7 +6668,7 @@ def ===(other)
   #     end
   #
   class In < Node
-    # [untyped] the pattern to check against
+    # [Node] the pattern to check against
     attr_reader :pattern
 
     # [Statements] the expressions to execute if the pattern matched
@@ -7450,7 +7451,7 @@ class MAssign < Node
     # [MLHS | MLHSParen] the target of the multiple assignment
     attr_reader :target
 
-    # [untyped] the value being assigned
+    # [Node] the value being assigned
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -7510,10 +7511,10 @@ def ===(other)
   #     method {}
   #
   class MethodAddBlock < Node
-    # [Call | Command | CommandCall] the method call
+    # [ARef | CallNode | Command | CommandCall | Super | ZSuper] the method call
     attr_reader :call
 
-    # [Block] the block being sent with the method call
+    # [BlockNode] the block being sent with the method call
     attr_reader :block
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -7585,8 +7586,12 @@ def format_contents(q)
   #     first, second, third = value
   #
   class MLHS < Node
-    # Array[ARefField | ArgStar | Field | Ident | MLHSParen | VarField] the
-    # parts of the left-hand side of a multiple assignment
+    # [
+    #   Array[
+    #     ARefField | ArgStar | ConstPathField | Field | Ident | MLHSParen |
+    #       TopConstField | VarField
+    #   ]
+    # ] the parts of the left-hand side of a multiple assignment
     attr_reader :parts
 
     # [boolean] whether or not there is a trailing comma at the end of this
@@ -7812,7 +7817,7 @@ def format_declaration(q)
   #     values = first, second, third
   #
   class MRHS < Node
-    # Array[untyped] the parts that are being assigned
+    # [Array[Node]] the parts that are being assigned
     attr_reader :parts
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -7988,7 +7993,7 @@ class OpAssign < Node
     # [Op] the operator being used for the assignment
     attr_reader :operator
 
-    # [untyped] the expression to be assigned
+    # [Node] the expression to be assigned
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -8145,7 +8150,7 @@ class OptionalFormatter
       # [Ident] the name of the parameter
       attr_reader :name
 
-      # [untyped] the value of the parameter
+      # [Node] the value of the parameter
       attr_reader :value
 
       def initialize(name, value)
@@ -8170,7 +8175,7 @@ class KeywordFormatter
       # [Ident] the name of the parameter
       attr_reader :name
 
-      # [nil | untyped] the value of the parameter
+      # [nil | Node] the value of the parameter
       attr_reader :value
 
       def initialize(name, value)
@@ -8211,10 +8216,10 @@ def format(q)
       end
     end
 
-    # [Array[ Ident ]] any required parameters
+    # [Array[ Ident | MLHSParen ]] any required parameters
     attr_reader :requireds
 
-    # [Array[ [ Ident, untyped ] ]] any optional parameters and their default
+    # [Array[ [ Ident, Node ] ]] any optional parameters and their default
     # values
     attr_reader :optionals
 
@@ -8226,11 +8231,12 @@ def format(q)
     # parameter
     attr_reader :posts
 
-    # [Array[ [ Ident, nil | untyped ] ]] any keyword parameters and their
+    # [Array[ [ Label, nil | Node ] ]] any keyword parameters and their
     # optional default values
     attr_reader :keywords
 
-    # [nil | :nil | KwRestParam] the optional keyword rest parameter
+    # [nil | :nil | ArgsForward | KwRestParam] the optional keyword rest
+    # parameter
     attr_reader :keyword_rest
 
     # [nil | BlockArg] the optional block parameter
@@ -8419,7 +8425,7 @@ class Paren < Node
     # [LParen] the left parenthesis that opened this statement
     attr_reader :lparen
 
-    # [nil | untyped] the expression inside the parentheses
+    # [nil | Node] the expression inside the parentheses
     attr_reader :contents
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -9268,7 +9274,7 @@ def ambiguous?(q)
   #     end
   #
   class RescueEx < Node
-    # [untyped] the list of exceptions being rescued
+    # [nil | Node] the list of exceptions being rescued
     attr_reader :exceptions
 
     # [nil | Field | VarField] the expression being used to capture the raised
@@ -9346,7 +9352,7 @@ class Rescue < Node
     # [Kw] the rescue keyword
     attr_reader :keyword
 
-    # [RescueEx] the exceptions being rescued
+    # [nil | RescueEx] the exceptions being rescued
     attr_reader :exception
 
     # [Statements] the expressions to evaluate when an error is rescued
@@ -9466,10 +9472,10 @@ def ===(other)
   #     expression rescue value
   #
   class RescueMod < Node
-    # [untyped] the expression to execute
+    # [Node] the expression to execute
     attr_reader :statement
 
-    # [untyped] the value to use if the executed expression raises an error
+    # [Node] the value to use if the executed expression raises an error
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -9728,7 +9734,7 @@ def ===(other)
   #     end
   #
   class SClass < Node
-    # [untyped] the target of the singleton class to enter
+    # [Node] the target of the singleton class to enter
     attr_reader :target
 
     # [BodyStmt] the expressions to be executed
@@ -9802,10 +9808,10 @@ def ===(other)
   # propagate that onto void_stmt nodes inside the stmts in order to make sure
   # all comments get printed appropriately.
   class Statements < Node
-    # [SyntaxTree] the parser that is generating this node
+    # [Parser] the parser that is generating this node
     attr_reader :parser
 
-    # [Array[ untyped ]] the list of expressions contained within this node
+    # [Array[ Node ]] the list of expressions contained within this node
     attr_reader :body
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -9995,9 +10001,13 @@ class StringContent < Node
     # string
     attr_reader :parts
 
+    # [Array[ Comment | EmbDoc ]] the comments attached to this node
+    attr_reader :comments
+
     def initialize(parts:, location:)
       @parts = parts
       @location = location
+      @comments = []
     end
 
     def accept(visitor)
@@ -10024,6 +10034,33 @@ def deconstruct_keys(_keys)
     def ===(other)
       other.is_a?(StringContent) && ArrayMatch.call(parts, other.parts)
     end
+
+    def format(q)
+      q.text(q.quote)
+      q.group do
+        parts.each do |part|
+          if part.is_a?(TStringContent)
+            value = Quotes.normalize(part.value, q.quote)
+            first = true
+
+            value.each_line(chomp: true) do |line|
+              if first
+                first = false
+              else
+                q.breakable_return
+              end
+
+              q.text(line)
+            end
+
+            q.breakable_return if value.end_with?("\n")
+          else
+            q.format(part)
+          end
+        end
+      end
+      q.text(q.quote)
+    end
   end
 
   # StringConcat represents concatenating two strings together using a backward
@@ -10033,7 +10070,8 @@ def ===(other)
   #       "second"
   #
   class StringConcat < Node
-    # [StringConcat | StringLiteral] the left side of the concatenation
+    # [Heredoc | StringConcat | StringLiteral] the left side of the
+    # concatenation
     attr_reader :left
 
     # [StringLiteral] the right side of the concatenation
@@ -10230,7 +10268,7 @@ class StringLiteral < Node
     # string literal
     attr_reader :parts
 
-    # [String] which quote was used by the string literal
+    # [nil | String] which quote was used by the string literal
     attr_reader :quote
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -10475,8 +10513,8 @@ def ===(other)
   #     :symbol
   #
   class SymbolLiteral < Node
-    # [Backtick | Const | CVar | GVar | Ident | IVar | Kw | Op] the value of the
-    # symbol
+    # [Backtick | Const | CVar | GVar | Ident | IVar | Kw | Op | TStringContent]
+    # the value of the symbol
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -10985,7 +11023,7 @@ def ===(other)
   #     not value
   #
   class Not < Node
-    # [nil | untyped] the statement on which to operate
+    # [nil | Node] the statement on which to operate
     attr_reader :statement
 
     # [boolean] whether or not parentheses were used
@@ -11072,7 +11110,7 @@ class Unary < Node
     # [String] the operator being used
     attr_reader :operator
 
-    # [untyped] the statement on which to operate
+    # [Node] the statement on which to operate
     attr_reader :statement
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -11216,7 +11254,7 @@ def ===(other)
   #     end
   #
   class UnlessNode < Node
-    # [untyped] the expression to be checked
+    # [Node] the expression to be checked
     attr_reader :predicate
 
     # [Statements] the expressions to be executed
@@ -11362,7 +11400,7 @@ def format_break(q)
   #     end
   #
   class UntilNode < Node
-    # [untyped] the expression to be checked
+    # [Node] the expression to be checked
     attr_reader :predicate
 
     # [Statements] the expressions to be executed
@@ -11430,7 +11468,7 @@ def modifier?
   #
   # In the example above, the VarField node represents the +variable+ token.
   class VarField < Node
-    # [nil | Const | CVar | GVar | Ident | IVar] the target of this node
+    # [nil | :nil | Const | CVar | GVar | Ident | IVar] the target of this node
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -11569,7 +11607,7 @@ def pin(parent, pin)
   # This can be a plain local variable like the example above. It can also be a
   # a class variable, a global variable, or an instance variable.
   class PinnedVarRef < Node
-    # [VarRef] the value of this node
+    # [Const | CVar | GVar | Ident | IVar] the value of this node
     attr_reader :value
 
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
@@ -11683,9 +11721,6 @@ def arity
   #     ;;
   #
   class VoidStmt < Node
-    # [Location] the location of this node
-    attr_reader :location
-
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
@@ -11846,7 +11881,7 @@ def ===(other)
   #     end
   #
   class WhileNode < Node
-    # [untyped] the expression to be checked
+    # [Node] the expression to be checked
     attr_reader :predicate
 
     # [Statements] the expressions to be executed
diff --git a/lib/syntax_tree/parser.rb b/lib/syntax_tree/parser.rb
index 59128875..c15a0339 100644
--- a/lib/syntax_tree/parser.rb
+++ b/lib/syntax_tree/parser.rb
@@ -908,6 +908,18 @@ def on_blockarg(name)
     #     (nil | Ensure) ensure_clause
     #   ) -> BodyStmt
     def on_bodystmt(statements, rescue_clause, else_clause, ensure_clause)
+      # In certain versions of Ruby, the `statements` argument can be any node
+      # in the case that we're inside of an endless method definition. In this
+      # case we'll wrap it in a Statements node to be consistent.
+      unless statements.is_a?(Statements)
+        statements =
+          Statements.new(
+            self,
+            body: [statements],
+            location: statements.location
+          )
+      end
+
       parts = [statements, rescue_clause, else_clause, ensure_clause].compact
 
       BodyStmt.new(
@@ -1157,13 +1169,23 @@ def on_const(value)
     end
 
     # :call-seq:
-    #   on_const_path_field: (untyped parent, Const constant) -> ConstPathField
+    #   on_const_path_field: (untyped parent, Const constant) ->
+    #     ConstPathField | Field
     def on_const_path_field(parent, constant)
-      ConstPathField.new(
-        parent: parent,
-        constant: constant,
-        location: parent.location.to(constant.location)
-      )
+      if constant.is_a?(Const)
+        ConstPathField.new(
+          parent: parent,
+          constant: constant,
+          location: parent.location.to(constant.location)
+        )
+      else
+        Field.new(
+          parent: parent,
+          operator: consume_operator(:"::"),
+          name: constant,
+          location: parent.location.to(constant.location)
+        )
+      end
     end
 
     # :call-seq:
@@ -1866,10 +1888,42 @@ def on_heredoc_end(value)
     # :call-seq:
     #   on_hshptn: (
     #     (nil | untyped) constant,
-    #     Array[[Label, untyped]] keywords,
+    #     Array[[Label | StringContent, untyped]] keywords,
     #     (nil | VarField) keyword_rest
     #   ) -> HshPtn
     def on_hshptn(constant, keywords, keyword_rest)
+      keywords =
+        (keywords || []).map do |(label, value)|
+          if label.is_a?(Label)
+            [label, value]
+          else
+            tstring_beg_index =
+              tokens.rindex do |token|
+                token.is_a?(TStringBeg) &&
+                  token.location.start_char < label.location.start_char
+              end
+
+            tstring_beg = tokens.delete_at(tstring_beg_index)
+
+            label_end_index =
+              tokens.rindex do |token|
+                token.is_a?(LabelEnd) &&
+                  token.location.start_char == label.location.end_char
+              end
+
+            label_end = tokens.delete_at(label_end_index)
+
+            [
+              DynaSymbol.new(
+                parts: label.parts,
+                quote: label_end.value[0],
+                location: tstring_beg.location.to(label_end.location)
+              ),
+              value
+            ]
+          end
+        end
+
       if keyword_rest
         # We're doing this to delete the token from the list so that it doesn't
         # confuse future patterns by thinking they have an extra ** on the end.
@@ -1882,7 +1936,7 @@ def on_hshptn(constant, keywords, keyword_rest)
         keyword_rest = VarField.new(value: nil, location: token.location)
       end
 
-      parts = [constant, *keywords&.flatten(1), keyword_rest].compact
+      parts = [constant, *keywords.flatten(1), keyword_rest].compact
 
       # If there's no constant, there may be braces, so we're going to look for
       # those to get our bounds.
@@ -1899,7 +1953,7 @@ def on_hshptn(constant, keywords, keyword_rest)
 
       HshPtn.new(
         constant: constant,
-        keywords: keywords || [],
+        keywords: keywords,
         keyword_rest: keyword_rest,
         location: parts[0].location.to(parts[-1].location)
       )
@@ -2379,7 +2433,7 @@ def on_method_add_block(call, block)
       location = call.location.to(block.location)
 
       case call
-      when Break, Next
+      when Break, Next, ReturnNode
         parts = call.arguments.parts
 
         node = parts.pop
diff --git a/lib/syntax_tree/reflection.rb b/lib/syntax_tree/reflection.rb
new file mode 100644
index 00000000..bf4b95f3
--- /dev/null
+++ b/lib/syntax_tree/reflection.rb
@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  # This module is used to provide some reflection on the various types of nodes
+  # and their attributes. As soon as it is required it collects all of its
+  # information.
+  module Reflection
+    # This module represents the type of the values being passed to attributes
+    # of nodes. It is used as part of the documentation of the attributes.
+    module Type
+      CONSTANTS = SyntaxTree.constants.to_h { [_1, SyntaxTree.const_get(_1)] }
+
+      # Represents an array type that holds another type.
+      class ArrayType
+        attr_reader :type
+
+        def initialize(type)
+          @type = type
+        end
+
+        def ===(value)
+          value.is_a?(Array) && value.all? { type === _1 }
+        end
+
+        def inspect
+          "Array<#{type.inspect}>"
+        end
+      end
+
+      # Represents a tuple type that holds a number of types in order.
+      class TupleType
+        attr_reader :types
+
+        def initialize(types)
+          @types = types
+        end
+
+        def ===(value)
+          value.is_a?(Array) && value.length == types.length &&
+            value.zip(types).all? { |item, type| type === item }
+        end
+
+        def inspect
+          "[#{types.map(&:inspect).join(", ")}]"
+        end
+      end
+
+      # Represents a union type that can be one of a number of types.
+      class UnionType
+        attr_reader :types
+
+        def initialize(types)
+          @types = types
+        end
+
+        def ===(value)
+          types.any? { _1 === value }
+        end
+
+        def inspect
+          types.map(&:inspect).join(" | ")
+        end
+      end
+
+      class << self
+        def parse(comment)
+          comment = comment.gsub(/\n/, " ")
+
+          unless comment.start_with?("[")
+            raise "Comment does not start with a bracket: #{comment.inspect}"
+          end
+
+          count = 1
+          found =
+            comment.chars[1..]
+              .find
+              .with_index(1) do |char, index|
+                count += { "[" => 1, "]" => -1 }.fetch(char, 0)
+                break index if count == 0
+              end
+
+          # If we weren't able to find the end of the balanced brackets, then
+          # the comment is malformed.
+          if found.nil?
+            raise "Comment does not have balanced brackets: #{comment.inspect}"
+          end
+
+          parse_type(comment[1...found].strip)
+        end
+
+        private
+
+        def parse_type(value)
+          case value
+          when "Integer"
+            Integer
+          when "String"
+            String
+          when "Symbol"
+            Symbol
+          when "boolean"
+            UnionType.new([TrueClass, FalseClass])
+          when "nil"
+            NilClass
+          when ":\"::\""
+            :"::"
+          when ":call"
+            :call
+          when ":nil"
+            :nil
+          when /\AArray\[(.+)\]\z/
+            ArrayType.new(parse_type($1.strip))
+          when /\A\[(.+)\]\z/
+            TupleType.new($1.strip.split(/\s*,\s*/).map { parse_type(_1) })
+          else
+            if value.include?("|")
+              UnionType.new(value.split(/\s*\|\s*/).map { parse_type(_1) })
+            else
+              CONSTANTS.fetch(value.to_sym)
+            end
+          end
+        end
+      end
+    end
+
+    # This class represents one of the attributes on a node in the tree.
+    class Attribute
+      attr_reader :name, :comment, :type
+
+      def initialize(name, comment)
+        @name = name
+        @comment = comment
+        @type = Type.parse(comment)
+      end
+    end
+
+    # This class represents one of our nodes in the tree. We're going to use it
+    # as a placeholder for collecting all of the various places that nodes are
+    # used.
+    class Node
+      attr_reader :name, :comment, :attributes
+
+      def initialize(name, comment, attributes)
+        @name = name
+        @comment = comment
+        @attributes = attributes
+      end
+    end
+
+    class << self
+      # This is going to hold a hash of all of the nodes in the tree. The keys
+      # are the names of the nodes as symbols.
+      attr_reader :nodes
+
+      # This expects a node name as a symbol and returns the node object for
+      # that node.
+      def node(name)
+        nodes.fetch(name)
+      end
+
+      private
+
+      def parse_comments(statements, index)
+        statements[0...index]
+          .reverse_each
+          .take_while { _1.is_a?(SyntaxTree::Comment) }
+          .reverse_each
+          .map { _1.value[2..] }
+      end
+    end
+
+    @nodes = {}
+
+    # For each node, we're going to parse out its attributes and other metadata.
+    # We'll use this as the basis for our report.
+    program =
+      SyntaxTree.parse(SyntaxTree.read(File.expand_path("node.rb", __dir__)))
+
+    main_statements = program.statements.body.last.bodystmt.statements.body
+    main_statements.each_with_index do |main_statement, main_statement_index|
+      # Ensure we are only looking at class declarations.
+      next unless main_statement.is_a?(SyntaxTree::ClassDeclaration)
+
+      # Ensure we're looking at class declarations with superclasses.
+      next unless main_statement.superclass.is_a?(SyntaxTree::VarRef)
+
+      # Ensure we're looking at class declarations that inherit from Node.
+      next unless main_statement.superclass.value.value == "Node"
+
+      # All child nodes inherit the location attr_reader from Node, so we'll add
+      # that to the list of attributes first.
+      attributes = {
+        location:
+          Attribute.new(:location, "[Location] the location of this node")
+      }
+
+      statements = main_statement.bodystmt.statements.body
+      statements.each_with_index do |statement, statement_index|
+        case statement
+        when SyntaxTree::Command
+          # We only use commands in node classes to define attributes. So, we
+          # can safely assume that we're looking at an attribute definition.
+          unless %w[attr_reader attr_accessor].include?(statement.message.value)
+            raise "Unexpected command: #{statement.message.value.inspect}"
+          end
+
+          # The arguments to the command are the attributes that we're defining.
+          # We want to ensure that we're only defining one at a time.
+          if statement.arguments.parts.length != 1
+            raise "Declaring more than one attribute at a time is not permitted"
+          end
+
+          attribute =
+            Attribute.new(
+              statement.arguments.parts.first.value.value.to_sym,
+              "#{parse_comments(statements, statement_index).join("\n")}\n"
+            )
+
+          # Ensure that we don't already have an attribute named the same as
+          # this one, and then add it to the list of attributes.
+          if attributes.key?(attribute.name)
+            raise "Duplicate attribute: #{attribute.name}"
+          end
+
+          attributes[attribute.name] = attribute
+        end
+      end
+
+      # Finally, set it up in the hash of nodes so that we can use it later.
+      comments = parse_comments(main_statements, main_statement_index)
+      node =
+        Node.new(
+          main_statement.constant.constant.value.to_sym,
+          "#{comments.join("\n")}\n",
+          attributes
+        )
+
+      @nodes[node.name] = node
+    end
+  end
+end
diff --git a/lib/syntax_tree/translation/parser.rb b/lib/syntax_tree/translation/parser.rb
index 4a4b6ade..184bb165 100644
--- a/lib/syntax_tree/translation/parser.rb
+++ b/lib/syntax_tree/translation/parser.rb
@@ -1068,7 +1068,7 @@ def visit_field(node)
           case stack[-2]
           when Assign, MLHS
             Ident.new(
-              value: :"#{node.name.value}=",
+              value: "#{node.name.value}=",
               location: node.name.location
             )
           else
@@ -1295,11 +1295,11 @@ def visit_hshptn(node)
             next s(:pair, [visit(keyword), visit(value)], nil) if value
 
             case keyword
-            when Label
-              s(:match_var, [keyword.value.chomp(":").to_sym], nil)
-            when StringContent
+            when DynaSymbol
               raise if keyword.parts.length > 1
               s(:match_var, [keyword.parts.first.value.to_sym], nil)
+            when Label
+              s(:match_var, [keyword.value.chomp(":").to_sym], nil)
             end
           end
 
@@ -2364,13 +2364,9 @@ def visit_statements(node)
 
       # Visit a StringConcat node.
       def visit_string_concat(node)
-        visit_string_literal(
-          StringLiteral.new(
-            parts: [node.left, node.right],
-            quote: nil,
-            location: node.location
-          )
-        )
+        location = source_map_collection(expression: source_range_node(node))
+
+        s(:dstr, [visit(node.left), visit(node.right)], location)
       end
 
       # Visit a StringContent node.
diff --git a/lib/syntax_tree/yarv/compiler.rb b/lib/syntax_tree/yarv/compiler.rb
index c1b4d6dd..3aff3fe5 100644
--- a/lib/syntax_tree/yarv/compiler.rb
+++ b/lib/syntax_tree/yarv/compiler.rb
@@ -1050,11 +1050,21 @@ def visit_if_op(node)
         visit_if(
           IfNode.new(
             predicate: node.predicate,
-            statements: node.truthy,
+            statements:
+              Statements.new(
+                nil,
+                body: [node.truthy],
+                location: Location.default
+              ),
             consequent:
               Else.new(
                 keyword: Kw.new(value: "else", location: Location.default),
-                statements: node.falsy,
+                statements:
+                  Statements.new(
+                    nil,
+                    body: [node.falsy],
+                    location: Location.default
+                  ),
                 location: Location.default
               ),
             location: Location.default
diff --git a/lib/syntax_tree/yarv/decompiler.rb b/lib/syntax_tree/yarv/decompiler.rb
index 753ba80a..4ea99e3a 100644
--- a/lib/syntax_tree/yarv/decompiler.rb
+++ b/lib/syntax_tree/yarv/decompiler.rb
@@ -151,7 +151,7 @@ def decompile(iseq)
               elsif argc == 1 && method.end_with?("=")
                 receiver, argument = clause.pop(2)
                 clause << Assign(
-                  CallNode(receiver, Period("."), Ident(method[0..-2]), nil),
+                  Field(receiver, Period("."), Ident(method[0..-2])),
                   argument
                 )
               else
diff --git a/tasks/sorbet.rake b/tasks/sorbet.rake
new file mode 100644
index 00000000..e4152664
--- /dev/null
+++ b/tasks/sorbet.rake
@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  class RBI
+    include DSL
+
+    attr_reader :body, :line
+
+    def initialize
+      @body = []
+      @line = 1
+    end
+
+    def generate
+      require "syntax_tree/reflection"
+
+      body << Comment("# typed: strict", false, location)
+      @line += 2
+
+      generate_parent
+      Reflection.nodes.sort.each { |(_, node)| generate_node(node) }
+
+      Formatter.format(nil, Program(Statements(body)))
+    end
+
+    private
+
+    def generate_comments(comment)
+      comment
+        .lines(chomp: true)
+        .map { |line| Comment("# #{line}", false, location).tap { @line += 1 } }
+    end
+
+    def generate_parent
+      attribute = Reflection.nodes[:Program].attributes[:location]
+      class_location = location
+
+      node_body = generate_comments(attribute.comment)
+      node_body << sig_block { sig_returns { sig_type_for(attribute.type) } }
+      @line += 1
+
+      node_body << Command(
+        Ident("attr_reader"),
+        Args([SymbolLiteral(Ident("location"))]),
+        nil,
+        location
+      )
+      @line += 1
+
+      body << ClassDeclaration(
+        ConstPathRef(VarRef(Const("SyntaxTree")), Const("Node")),
+        nil,
+        BodyStmt(Statements(node_body), nil, nil, nil, nil),
+        class_location
+      )
+      @line += 2
+    end
+
+    def generate_node(node)
+      body.concat(generate_comments(node.comment))
+      class_location = location
+      @line += 2
+
+      body << ClassDeclaration(
+        ConstPathRef(VarRef(Const("SyntaxTree")), Const(node.name.to_s)),
+        ConstPathRef(VarRef(Const("SyntaxTree")), Const("Node")),
+        BodyStmt(Statements(generate_node_body(node)), nil, nil, nil, nil),
+        class_location
+      )
+
+      @line += 2
+    end
+
+    def generate_node_body(node)
+      node_body = []
+      node.attributes.sort.each do |(name, attribute)|
+        next if name == :location
+
+        node_body.concat(generate_comments(attribute.comment))
+        node_body << sig_block { sig_returns { sig_type_for(attribute.type) } }
+        @line += 1
+
+        node_body << Command(
+          Ident("attr_reader"),
+          Args([SymbolLiteral(Ident(attribute.name.to_s))]),
+          nil,
+          location
+        )
+        @line += 2
+      end
+
+      node_body.concat(generate_initialize(node))
+
+      node_body << sig_block do
+        CallNode(
+          sig_params do
+            BareAssocHash(
+              [Assoc(Label("visitor:"), sig_type_for(BasicVisitor))]
+            )
+          end,
+          Period("."),
+          Ident("returns"),
+          ArgParen(
+            Args(
+              [CallNode(VarRef(Const("T")), Period("."), Ident("untyped"), nil)]
+            )
+          )
+        )
+      end
+      @line += 1
+
+      node_body << generate_def_node(
+        "accept",
+        Paren(
+          LParen("("),
+          Params.new(requireds: [Ident("visitor")], location: location)
+        )
+      )
+      @line += 2
+
+      node_body << generate_child_nodes
+      @line += 1
+
+      node_body << generate_def_node("child_nodes", nil)
+      @line += 1
+
+      node_body
+    end
+
+    def generate_initialize(node)
+      parameters =
+        SyntaxTree.const_get(node.name).instance_method(:initialize).parameters
+
+      assocs =
+        parameters.map do |(_, name)|
+          Assoc(Label("#{name}:"), sig_type_for(node.attributes[name].type))
+        end
+
+      node_body = []
+      node_body << sig_block do
+        CallNode(
+          sig_params { BareAssocHash(assocs) },
+          Period("."),
+          Ident("void"),
+          nil
+        )
+      end
+      @line += 1
+
+      params = Params.new(location: location)
+      parameters.each do |(type, name)|
+        case type
+        when :req
+          params.requireds << Ident(name.to_s)
+        when :keyreq
+          params.keywords << [Label("#{name}:"), nil]
+        when :key
+          params.keywords << [
+            Label("#{name}:"),
+            CallNode(
+              VarRef(Const("T")),
+              Period("."),
+              Ident("unsafe"),
+              ArgParen(Args([VarRef(Kw("nil"))]))
+            )
+          ]
+        else
+          raise
+        end
+      end
+
+      node_body << generate_def_node("initialize", Paren(LParen("("), params))
+      @line += 2
+
+      node_body
+    end
+
+    def generate_child_nodes
+      type =
+        Reflection::Type::ArrayType.new(
+          Reflection::Type::UnionType.new([NilClass, Node])
+        )
+
+      sig_block { sig_returns { sig_type_for(type) } }
+    end
+
+    def generate_def_node(name, params)
+      DefNode(
+        nil,
+        nil,
+        Ident(name),
+        params,
+        BodyStmt(Statements([VoidStmt()]), nil, nil, nil, nil),
+        location
+      )
+    end
+
+    def sig_block
+      MethodAddBlock(
+        CallNode(nil, nil, Ident("sig"), nil),
+        BlockNode(
+          LBrace("{"),
+          nil,
+          BodyStmt(Statements([yield]), nil, nil, nil, nil)
+        ),
+        location
+      )
+    end
+
+    def sig_params
+      CallNode(nil, nil, Ident("params"), ArgParen(Args([yield])))
+    end
+
+    def sig_returns
+      CallNode(nil, nil, Ident("returns"), ArgParen(Args([yield])))
+    end
+
+    def sig_type_for(type)
+      case type
+      when Reflection::Type::ArrayType
+        ARef(
+          ConstPathRef(VarRef(Const("T")), Const("Array")),
+          sig_type_for(type.type)
+        )
+      when Reflection::Type::TupleType
+        ArrayLiteral(LBracket("["), Args(type.types.map { sig_type_for(_1) }))
+      when Reflection::Type::UnionType
+        if type.types.include?(NilClass)
+          selected = type.types.reject { _1 == NilClass }
+          subtype =
+            if selected.size == 1
+              selected.first
+            else
+              Reflection::Type::UnionType.new(selected)
+            end
+
+          CallNode(
+            VarRef(Const("T")),
+            Period("."),
+            Ident("nilable"),
+            ArgParen(Args([sig_type_for(subtype)]))
+          )
+        else
+          CallNode(
+            VarRef(Const("T")),
+            Period("."),
+            Ident("any"),
+            ArgParen(Args(type.types.map { sig_type_for(_1) }))
+          )
+        end
+      when Symbol
+        ConstRef(Const("Symbol"))
+      else
+        *parents, constant = type.name.split("::").map { Const(_1) }
+
+        if parents.empty?
+          ConstRef(constant)
+        else
+          [*parents[1..], constant].inject(
+            VarRef(parents.first)
+          ) { |accum, const| ConstPathRef(accum, const) }
+        end
+      end
+    end
+
+    def location
+      Location.fixed(line: line, char: 0, column: 0)
+    end
+  end
+end
+
+namespace :sorbet do
+  desc "Generate RBI files for Sorbet"
+  task :rbi do
+    puts SyntaxTree::RBI.new.generate
+  end
+end
diff --git a/test/formatting_test.rb b/test/formatting_test.rb
index 37ca29e1..5e5f9e9f 100644
--- a/test/formatting_test.rb
+++ b/test/formatting_test.rb
@@ -7,6 +7,7 @@ class FormattingTest < Minitest::Test
     Fixtures.each_fixture do |fixture|
       define_method(:"test_formatted_#{fixture.name}") do
         assert_equal(fixture.formatted, SyntaxTree.format(fixture.source))
+        assert_syntax_tree(SyntaxTree.parse(fixture.source))
       end
     end
 
diff --git a/test/interface_test.rb b/test/interface_test.rb
deleted file mode 100644
index 5086680e..00000000
--- a/test/interface_test.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-module SyntaxTree
-  class InterfaceTest < Minitest::Test
-    ObjectSpace.each_object(Node.singleton_class) do |klass|
-      next if klass == Node
-
-      define_method(:"test_instantiate_#{klass.name}") do
-        assert_syntax_tree(instantiate(klass))
-      end
-    end
-
-    Fixtures.each_fixture do |fixture|
-      define_method(:"test_#{fixture.name}") do
-        assert_syntax_tree(SyntaxTree.parse(fixture.source))
-      end
-    end
-
-    private
-
-    # This method is supposed to instantiate a new instance of the given class.
-    # The class is always a descendant from SyntaxTree::Node, so we can make
-    # certain assumptions about the way the initialize method is set up. If it
-    # needs to be special-cased, it's done so at the end of this method.
-    def instantiate(klass)
-      params = {}
-
-      # Set up all of the keyword parameters for the class.
-      klass
-        .instance_method(:initialize)
-        .parameters
-        .each { |(type, name)| params[name] = nil if type.start_with?("key") }
-
-      # Set up any default values that have to be arrays.
-      %i[
-        assocs
-        comments
-        elements
-        keywords
-        locals
-        optionals
-        parts
-        posts
-        requireds
-        symbols
-        values
-      ].each { |key| params[key] = [] if params.key?(key) }
-
-      # Set up a default location for the node.
-      params[:location] = Location.fixed(line: 0, char: 0, column: 0)
-
-      case klass.name
-      when "SyntaxTree::Binary"
-        klass.new(**params, operator: :+)
-      when "SyntaxTree::Kw"
-        klass.new(**params, value: "kw")
-      when "SyntaxTree::Label"
-        klass.new(**params, value: "label:")
-      when "SyntaxTree::Op"
-        klass.new(**params, value: "+")
-      when "SyntaxTree::RegexpLiteral"
-        klass.new(**params, ending: "/")
-      when "SyntaxTree::Statements"
-        klass.new(nil, **params, body: [])
-      else
-        klass.new(**params)
-      end
-    end
-  end
-end
diff --git a/test/test_helper.rb b/test/test_helper.rb
index 77627e26..18159fab 100644
--- a/test/test_helper.rb
+++ b/test/test_helper.rb
@@ -11,6 +11,37 @@
 require "syntax_tree"
 require "syntax_tree/cli"
 
+require "syntax_tree/reflection"
+
+SyntaxTree::Reflection.nodes.each do |name, node|
+  next if name == :Statements
+
+  clazz = SyntaxTree.const_get(name)
+  parameters = clazz.instance_method(:initialize).parameters
+
+  # First, verify that all of the parameters listed in the list of attributes.
+  # If there are any parameters that aren't listed in the attributes, then
+  # something went wrong with the parsing in the reflection module.
+  raise unless (parameters.map(&:last) - node.attributes.keys).empty?
+
+  # Now we're going to use an alias chain to redefine the initialize method to
+  # include type checking.
+  clazz.alias_method(:initialize_without_verify, :initialize)
+  clazz.define_method(:initialize) do |**kwargs|
+    kwargs.each do |kwarg, value|
+      attribute = node.attributes.fetch(kwarg)
+
+      unless attribute.type === value
+        raise TypeError,
+              "invalid type for #{name}##{kwarg}, expected " \
+                "#{attribute.type.inspect}, got #{value.inspect}"
+      end
+    end
+
+    initialize_without_verify(**kwargs)
+  end
+end
+
 require "json"
 require "tempfile"
 require "pp"