diff --git a/.gitignore b/.gitignore
index 69755243..3ce1e327 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@
 /coverage/
 /pkg/
 /rdocs/
+/sorbet/
 /spec/reports/
 /tmp/
 /vendor/
diff --git a/.rubocop.yml b/.rubocop.yml
index e74cdc1b..c1c17001 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -7,7 +7,7 @@ AllCops:
   SuggestExtensions: false
   TargetRubyVersion: 2.7
   Exclude:
-  - '{.git,.github,bin,coverage,pkg,spec,test/fixtures,vendor,tmp}/**/*'
+  - '{.git,.github,bin,coverage,pkg,sorbet,spec,test/fixtures,vendor,tmp}/**/*'
   - test.rb
 
 Gemspec/DevelopmentDependencies:
diff --git a/.ruby-version b/.ruby-version
new file mode 100644
index 00000000..944880fa
--- /dev/null
+++ b/.ruby-version
@@ -0,0 +1 @@
+3.2.0
diff --git a/lib/syntax_tree/node.rb b/lib/syntax_tree/node.rb
index 63a5d466..3f013b31 100644
--- a/lib/syntax_tree/node.rb
+++ b/lib/syntax_tree/node.rb
@@ -792,9 +792,10 @@ def arity
     private
 
     def trailing_comma?
+      arguments = self.arguments
       return false unless arguments.is_a?(Args)
-      parts = arguments.parts
 
+      parts = arguments.parts
       if parts.last.is_a?(ArgBlock)
         # If the last argument is a block, then we can't put a trailing comma
         # after it without resulting in a syntax error.
@@ -1188,8 +1189,11 @@ def deconstruct_keys(_keys)
     end
 
     def format(q)
-      if lbracket.comments.empty? && contents && contents.comments.empty? &&
-           contents.parts.length > 1
+      lbracket = self.lbracket
+      contents = self.contents
+
+      if lbracket.is_a?(LBracket) && lbracket.comments.empty? && contents &&
+           contents.comments.empty? && contents.parts.length > 1
         if qwords?
           QWordsFormatter.new(contents).format(q)
           return
@@ -2091,6 +2095,7 @@ def deconstruct_keys(_keys)
     end
 
     def format(q)
+      left = self.left
       power = operator == :**
 
       q.group do
@@ -2307,6 +2312,8 @@ def initialize(
     end
 
     def bind(parser, start_char, start_column, end_char, end_column)
+      rescue_clause = self.rescue_clause
+
       @location =
         Location.new(
           start_line: location.start_line,
@@ -2330,6 +2337,7 @@ def bind(parser, start_char, start_column, end_char, end_column)
       # Next we're going to determine the rescue clause if there is one
       if rescue_clause
         consequent = else_clause || ensure_clause
+
         rescue_clause.bind_end(
           consequent ? consequent.location.start_char : end_char,
           consequent ? consequent.location.start_column : end_column
@@ -2735,7 +2743,7 @@ def format(q)
               children << receiver
             end
           when MethodAddBlock
-            if receiver.call.is_a?(CallNode) && !receiver.call.receiver.nil?
+            if (call = receiver.call).is_a?(CallNode) && !call.receiver.nil?
               children << receiver
             else
               break
@@ -2744,8 +2752,8 @@ def format(q)
             break
           end
         when MethodAddBlock
-          if child.call.is_a?(CallNode) && !child.call.receiver.nil?
-            children << child.call
+          if (call = child.call).is_a?(CallNode) && !call.receiver.nil?
+            children << call
           else
             break
           end
@@ -2767,8 +2775,8 @@ def format(q)
         # of just Statements nodes.
         parent = parents[3] if parent.is_a?(BlockNode) && parent.keywords?
 
-        if parent.is_a?(MethodAddBlock) && parent.call.is_a?(CallNode) &&
-             parent.call.message.value == "sig"
+        if parent.is_a?(MethodAddBlock) &&
+             (call = parent.call).is_a?(CallNode) && call.message.value == "sig"
           threshold = 2
         end
       end
@@ -2813,10 +2821,10 @@ def format_chain(q, children)
 
           while (child = children.pop)
             if child.is_a?(CallNode)
-              if child.receiver.is_a?(CallNode) &&
-                   (child.receiver.message != :call) &&
-                   (child.receiver.message.value == "where") &&
-                   (child.message.value == "not")
+              if (receiver = child.receiver).is_a?(CallNode) &&
+                   (receiver.message != :call) &&
+                   (receiver.message.value == "where") &&
+                   (message.value == "not")
                 # This is very specialized behavior wherein we group
                 # .where.not calls together because it looks better. For more
                 # information, see
@@ -2872,7 +2880,8 @@ def self.chained?(node)
       when CallNode
         !node.receiver.nil?
       when MethodAddBlock
-        node.call.is_a?(CallNode) && !node.call.receiver.nil?
+        call = node.call
+        call.is_a?(CallNode) && !call.receiver.nil?
       else
         false
       end
@@ -3629,6 +3638,10 @@ def deconstruct_keys(_keys)
     end
 
     def format(q)
+      message = self.message
+      arguments = self.arguments
+      block = self.block
+
       q.group do
         doc =
           q.nest(0) do
@@ -3637,7 +3650,7 @@ def format(q)
             # If there are leading comments on the message then we know we have
             # a newline in the source that is forcing these things apart. In
             # this case we will have to use a trailing operator.
-            if message.comments.any?(&:leading?)
+            if message != :call && message.comments.any?(&:leading?)
               q.format(CallOperatorFormatter.new(operator), stackable: false)
               q.indent do
                 q.breakable_empty
@@ -4153,6 +4166,9 @@ def deconstruct_keys(_keys)
     end
 
     def format(q)
+      params = self.params
+      bodystmt = self.bodystmt
+
       q.group do
         q.group do
           q.text("def")
@@ -4209,6 +4225,8 @@ def endless?
     end
 
     def arity
+      params = self.params
+
       case params
       when Params
         params.arity
@@ -5293,6 +5311,7 @@ def accept(visitor)
     end
 
     def child_nodes
+      operator = self.operator
       [parent, (operator if operator != :"::"), name]
     end
 
@@ -5674,7 +5693,7 @@ def accept(visitor)
     end
 
     def child_nodes
-      [lbrace] + assocs
+      [lbrace].concat(assocs)
     end
 
     def copy(lbrace: nil, assocs: nil, location: nil)
@@ -5766,7 +5785,7 @@ class Heredoc < Node
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
-    def initialize(beginning:, ending: nil, dedent: 0, parts: [], location:)
+    def initialize(beginning:, location:, ending: nil, dedent: 0, parts: [])
       @beginning = beginning
       @ending = ending
       @dedent = dedent
@@ -6134,6 +6153,8 @@ def ===(other)
     private
 
     def format_contents(q, parts, nested)
+      keyword_rest = self.keyword_rest
+
       q.group { q.seplist(parts) { |part| q.format(part, stackable: false) } }
 
       # If there isn't a constant, and there's a blank keyword_rest, then we
@@ -6763,6 +6784,8 @@ def deconstruct_keys(_keys)
 
     def format(q)
       keyword = "in "
+      pattern = self.pattern
+      consequent = self.consequent
 
       q.group do
         q.text(keyword)
@@ -7165,6 +7188,8 @@ def deconstruct_keys(_keys)
     end
 
     def format(q)
+      params = self.params
+
       q.text("->")
       q.group do
         if params.is_a?(Paren)
@@ -7643,7 +7668,7 @@ class MLHS < Node
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
-    def initialize(parts:, comma: false, location:)
+    def initialize(parts:, location:, comma: false)
       @parts = parts
       @comma = comma
       @location = location
@@ -7704,7 +7729,7 @@ class MLHSParen < Node
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
-    def initialize(contents:, comma: false, location:)
+    def initialize(contents:, location:, comma: false)
       @contents = contents
       @comma = comma
       @location = location
@@ -8287,14 +8312,14 @@ def format(q)
     attr_reader :comments
 
     def initialize(
+      location:,
       requireds: [],
       optionals: [],
       rest: nil,
       posts: [],
       keywords: [],
       keyword_rest: nil,
-      block: nil,
-      location:
+      block: nil
     )
       @requireds = requireds
       @optionals = optionals
@@ -8321,6 +8346,8 @@ def accept(visitor)
     end
 
     def child_nodes
+      keyword_rest = self.keyword_rest
+
       [
         *requireds,
         *optionals.flatten(1),
@@ -8375,16 +8402,19 @@ def deconstruct_keys(_keys)
     end
 
     def format(q)
+      rest = self.rest
+      keyword_rest = self.keyword_rest
+
       parts = [
         *requireds,
         *optionals.map { |(name, value)| OptionalFormatter.new(name, value) }
       ]
 
       parts << rest if rest && !rest.is_a?(ExcessedComma)
-      parts += [
-        *posts,
-        *keywords.map { |(name, value)| KeywordFormatter.new(name, value) }
-      ]
+      parts.concat(posts)
+      parts.concat(
+        keywords.map { |(name, value)| KeywordFormatter.new(name, value) }
+      )
 
       parts << KeywordRestFormatter.new(keyword_rest) if keyword_rest
       parts << block if block
@@ -8511,6 +8541,8 @@ def deconstruct_keys(_keys)
     end
 
     def format(q)
+      contents = self.contents
+
       q.group do
         q.format(lparen)
 
@@ -9425,11 +9457,11 @@ def bind_end(end_char, end_column)
           end_column: end_column
         )
 
-      if consequent
-        consequent.bind_end(end_char, end_column)
+      if (next_node = consequent)
+        next_node.bind_end(end_char, end_column)
         statements.bind_end(
-          consequent.location.start_char,
-          consequent.location.start_column
+          next_node.location.start_char,
+          next_node.location.start_column
         )
       else
         statements.bind_end(end_char, end_column)
@@ -9872,8 +9904,8 @@ def bind(parser, start_char, start_column, end_char, end_column)
           end_column: end_column
         )
 
-      if body[0].is_a?(VoidStmt)
-        location = body[0].location
+      if (void_stmt = body[0]).is_a?(VoidStmt)
+        location = void_stmt.location
         location =
           Location.new(
             start_line: location.start_line,
@@ -10352,7 +10384,7 @@ def format(q)
       opening_quote, closing_quote =
         if !Quotes.locked?(self, q.quote)
           [q.quote, q.quote]
-        elsif quote.start_with?("%")
+        elsif quote&.start_with?("%")
           [quote, Quotes.matching(quote[/%[qQ]?(.)/, 1])]
         else
           [quote, quote]
@@ -11521,7 +11553,7 @@ def accept(visitor)
     end
 
     def child_nodes
-      [value]
+      value == :nil ? [] : [value]
     end
 
     def copy(value: nil, location: nil)
diff --git a/lib/syntax_tree/reflection.rb b/lib/syntax_tree/reflection.rb
index b2ffec6d..a27593ee 100644
--- a/lib/syntax_tree/reflection.rb
+++ b/lib/syntax_tree/reflection.rb
@@ -183,10 +183,11 @@ def parse_comments(statements, index)
       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)
+      superclass = main_statement.superclass
+      next unless superclass.is_a?(SyntaxTree::VarRef)
 
       # Ensure we're looking at class declarations that inherit from Node.
-      next unless main_statement.superclass.value.value == "Node"
+      next unless 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.
diff --git a/lib/syntax_tree/yarv/instruction_sequence.rb b/lib/syntax_tree/yarv/instruction_sequence.rb
index 45b543e6..5aaaef44 100644
--- a/lib/syntax_tree/yarv/instruction_sequence.rb
+++ b/lib/syntax_tree/yarv/instruction_sequence.rb
@@ -50,7 +50,7 @@ def initialize
           @tail_node = nil
         end
 
-        def each
+        def each(&_blk)
           return to_enum(__method__) unless block_given?
           each_node { |node| yield node.value }
         end
diff --git a/tasks/sorbet.rake b/tasks/sorbet.rake
index e4152664..c80ec91d 100644
--- a/tasks/sorbet.rake
+++ b/tasks/sorbet.rake
@@ -122,8 +122,41 @@ module SyntaxTree
       @line += 1
 
       node_body << generate_def_node("child_nodes", nil)
+      @line += 2
+
+      node_body << sig_block do
+        CallNode(
+          sig_params do
+            BareAssocHash(
+              [
+                Assoc(
+                  Label("other:"),
+                  CallNode(
+                    VarRef(Const("T")),
+                    Period("."),
+                    Ident("untyped"),
+                    nil
+                  )
+                )
+              ]
+            )
+          end,
+          Period("."),
+          sig_returns { ConstPathRef(VarRef(Const("T")), Const("Boolean")) },
+          nil
+        )
+      end
       @line += 1
 
+      node_body << generate_def_node(
+        "==",
+        Paren(
+          LParen("("),
+          Params.new(location: location, requireds: [Ident("other")])
+        )
+      )
+      @line += 2
+
       node_body
     end
 
diff --git a/test/language_server_test.rb b/test/language_server_test.rb
index 2fe4e60a..f5a6ca57 100644
--- a/test/language_server_test.rb
+++ b/test/language_server_test.rb
@@ -6,19 +6,38 @@
 module SyntaxTree
   # stree-ignore
   class LanguageServerTest < Minitest::Test
-    class Initialize < Struct.new(:id)
+    class Initialize
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
       def to_hash
         { method: "initialize", id: id }
       end
     end
 
-    class Shutdown < Struct.new(:id)
+    class Shutdown
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
       def to_hash
         { method: "shutdown", id: id }
       end
     end
 
-    class TextDocumentDidOpen < Struct.new(:uri, :text)
+    class TextDocumentDidOpen
+      attr_reader :uri, :text
+
+      def initialize(uri, text)
+        @uri = uri
+        @text = text
+      end
+
       def to_hash
         {
           method: "textDocument/didOpen",
@@ -27,7 +46,14 @@ def to_hash
       end
     end
 
-    class TextDocumentDidChange < Struct.new(:uri, :text)
+    class TextDocumentDidChange
+      attr_reader :uri, :text
+
+      def initialize(uri, text)
+        @uri = uri
+        @text = text
+      end
+
       def to_hash
         {
           method: "textDocument/didChange",
@@ -39,7 +65,13 @@ def to_hash
       end
     end
 
-    class TextDocumentDidClose < Struct.new(:uri)
+    class TextDocumentDidClose
+      attr_reader :uri
+
+      def initialize(uri)
+        @uri = uri
+      end
+
       def to_hash
         {
           method: "textDocument/didClose",
@@ -48,7 +80,14 @@ def to_hash
       end
     end
 
-    class TextDocumentFormatting < Struct.new(:id, :uri)
+    class TextDocumentFormatting
+      attr_reader :id, :uri
+
+      def initialize(id, uri)
+        @id = id
+        @uri = uri
+      end
+
       def to_hash
         {
           method: "textDocument/formatting",
@@ -58,7 +97,14 @@ def to_hash
       end
     end
 
-    class TextDocumentInlayHint < Struct.new(:id, :uri)
+    class TextDocumentInlayHint
+      attr_reader :id, :uri
+
+      def initialize(id, uri)
+        @id = id
+        @uri = uri
+      end
+
       def to_hash
         {
           method: "textDocument/inlayHint",
@@ -68,7 +114,14 @@ def to_hash
       end
     end
 
-    class SyntaxTreeVisualizing < Struct.new(:id, :uri)
+    class SyntaxTreeVisualizing
+      attr_reader :id, :uri
+
+      def initialize(id, uri)
+        @id = id
+        @uri = uri
+      end
+
       def to_hash
         {
           method: "syntaxTree/visualizing",