diff --git a/test/rbi/rewriters/add_sig_templates_test.rb b/test/rbi/rewriters/add_sig_templates_test.rb
index 7d4bd6e1..30005e4f 100644
--- a/test/rbi/rewriters/add_sig_templates_test.rb
+++ b/test/rbi/rewriters/add_sig_templates_test.rb
@@ -5,37 +5,44 @@
 
 module RBI
   class AddSigTemplatesTest < Minitest::Test
+    include TestHelper
+
     def test_do_not_add_sig_if_already_one
-      rbi = Tree.new
+      tree = parse_rbi(<<~RBI)
+        sig { returns(Integer) }
+        attr_reader :a
 
-      rbi << AttrReader.new(:a) do |attr|
-        attr.sigs << Sig.new(return_type: "Integer")
-      end
+        sig { returns(Integer) }
+        def foo; end
 
-      rbi << Method.new("m") do |meth|
-        meth.sigs << Sig.new(return_type: "Integer")
-      end
+        def bar; end
+      RBI
 
-      rbi.add_sig_templates!(with_todo_comment: true)
+      tree.add_sig_templates!(with_todo_comment: true)
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         sig { returns(Integer) }
         attr_reader :a
 
         sig { returns(Integer) }
-        def m; end
+        def foo; end
+
+        # TODO: fill in signature with appropriate type information
+        sig { returns(T.untyped) }
+        def bar; end
       RBI
     end
 
     def test_add_empty_sigs_to_attributes
-      rbi = Tree.new
-      rbi << AttrReader.new(:a1)
-      rbi << AttrWriter.new(:a2)
-      rbi << AttrAccessor.new(:a3)
+      tree = parse_rbi(<<~RBI)
+        attr_reader :a1
+        attr_writer :a2
+        attr_accessor :a3
+      RBI
 
-      rbi.add_sig_templates!(with_todo_comment: false)
+      tree.add_sig_templates!(with_todo_comment: false)
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         sig { returns(T.untyped) }
         attr_reader :a1
 
@@ -48,14 +55,15 @@ def test_add_empty_sigs_to_attributes
     end
 
     def test_add_empty_sigs_and_todo_comment_to_attributes
-      rbi = Tree.new
-      rbi << AttrReader.new(:a1)
-      rbi << AttrWriter.new(:a2)
-      rbi << AttrAccessor.new(:a3)
+      tree = parse_rbi(<<~RBI)
+        attr_reader :a1
+        attr_writer :a2
+        attr_accessor :a3
+      RBI
 
-      rbi.add_sig_templates!(with_todo_comment: true)
+      tree.add_sig_templates!(with_todo_comment: true)
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         # TODO: fill in signature with appropriate type information
         sig { returns(T.untyped) }
         attr_reader :a1
@@ -71,20 +79,15 @@ def test_add_empty_sigs_and_todo_comment_to_attributes
     end
 
     def test_add_empty_sigs_to_methods
-      rbi = Tree.new
-      rbi << Method.new("m1")
-      rbi << Method.new("m2") do |meth|
-        meth << ReqParam.new("x")
-      end
-      rbi << Method.new("m3", is_singleton: true) do |meth|
-        meth << ReqParam.new("x")
-        meth << OptParam.new("y", "42")
-        meth << KwRestParam.new("z")
-      end
-
-      rbi.add_sig_templates!(with_todo_comment: false)
-
-      assert_equal(<<~RBI, rbi.string)
+      tree = parse_rbi(<<~RBI)
+        def m1; end
+        def m2(x); end
+        def self.m3(x, y = 42, **z); end
+      RBI
+
+      tree.add_sig_templates!(with_todo_comment: false)
+
+      assert_equal(<<~RBI, tree.string)
         sig { returns(T.untyped) }
         def m1; end
 
@@ -97,20 +100,15 @@ def self.m3(x, y = 42, **z); end
     end
 
     def test_add_empty_sigs_and_todo_comment_to_methods
-      rbi = Tree.new
-      rbi << Method.new("m1")
-      rbi << Method.new("m2") do |meth|
-        meth << ReqParam.new("x")
-      end
-      rbi << Method.new("m3", is_singleton: true) do |meth|
-        meth << ReqParam.new("x")
-        meth << OptParam.new("y", "42")
-        meth << KwRestParam.new("z")
-      end
-
-      rbi.add_sig_templates!(with_todo_comment: true)
-
-      assert_equal(<<~RBI, rbi.string)
+      tree = parse_rbi(<<~RBI)
+        def m1; end
+        def m2(x); end
+        def self.m3(x, y = 42, **z); end
+      RBI
+
+      tree.add_sig_templates!(with_todo_comment: true)
+
+      assert_equal(<<~RBI, tree.string)
         # TODO: fill in signature with appropriate type information
         sig { returns(T.untyped) }
         def m1; end
diff --git a/test/rbi/rewriters/group_nodes_test.rb b/test/rbi/rewriters/group_nodes_test.rb
index 0f2ec2bb..05f6f499 100644
--- a/test/rbi/rewriters/group_nodes_test.rb
+++ b/test/rbi/rewriters/group_nodes_test.rb
@@ -5,40 +5,43 @@
 
 module RBI
   class GroupNodesTest < Minitest::Test
+    include TestHelper
+
     def test_group_nodes_in_tree
-      rbi = Tree.new
-      rbi << Const.new("C", "42")
-      rbi << Module.new("S1")
-      rbi << Class.new("S2")
-      rbi << Struct.new("S3")
-      rbi << Method.new("m1")
-      rbi << Method.new("m2", is_singleton: true)
-      rbi << Method.new("initialize")
-      rbi << Extend.new("E")
-      rbi << Include.new("I")
-      rbi << MixesInClassMethods.new("MICM")
-      rbi << Helper.new("h")
-      rbi << TStructConst.new("SC", "Type")
-      rbi << TStructProp.new("SP", "Type")
-      rbi << TEnum.new("TE")
-      rbi << SingletonClass.new
-      rbi << TStruct.new("TS")
-      rbi << Send.new("foo")
-      rbi << AttrWriter.new(:baz, :b)
-      rbi << AttrReader.new(:bar)
-      rbi << AttrAccessor.new(:foo, :a, :z)
-      rbi << RequiresAncestor.new("RA")
+      tree = parse_rbi(<<~RBI)
+        C = 42
+        module S1; end
+        class S2; end
+        S3 = ::Struct.new
+        def m1; end
+        def self.m2; end
+        def initialize; end
+        extend E
+        include I
+        mixes_in_class_methods MICM
+        abstract!
+        const :SC, Type
+        prop :SP, Type
+        class TE < ::T::Enum; end
+        class << self; end
+        class TS < ::T::Struct; end
+        foo
+        attr_writer :baz, :b
+        attr_reader :bar
+        attr_accessor :foo, :a, :z
+        requires_ancestor { RA }
+      RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         extend E
         include I
 
         requires_ancestor { RA }
 
-        h!
+        abstract!
 
         mixes_in_class_methods MICM
 
@@ -68,34 +71,33 @@ class TS < T::Struct; end
     end
 
     def test_group_nested_nodes
-      rbi = Tree.new
-
-      scope1 = Class.new("Scope1")
-      scope1 << Include.new("I1")
-      scope1 << Method.new("m1")
-      scope1 << Method.new("m2")
-      scope1 << Send.new("foo")
-
-      scope2 = Module.new("Scope2")
-      scope2 << Const.new("C1", "42")
-      scope2 << SingletonClass.new
-      scope2 << Const.new("C2", "42")
-      scope2 << Module.new("M1")
+      tree = parse_rbi(<<~RBI)
+        class Scope1
+          include I1
+          def m1; end
+          def m2; end
+          foo
 
-      scope3 = Struct.new("Scope3")
-      scope3 << Extend.new("E1")
-      scope3 << Extend.new("E2")
-      scope3 << MixesInClassMethods.new("MICM1")
-      scope3 << RequiresAncestor.new("RA1")
+          module Scope2
+            C1 = 42
+            class << self; end
+            C2 = 42
+            module M1; end
 
-      rbi << scope1
-      scope1 << scope2
-      scope2 << scope3
+            Scope3 = ::Struct.new do
+              extend E1
+              extend E2
+              mixes_in_class_methods MICM1
+              requires_ancestor { RA1 }
+            end
+          end
+        end
+      RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         class Scope1
           include I1
 
@@ -125,35 +127,36 @@ module M1; end
     end
 
     def test_group_sort_nodes_in_groups
-      rbi = Tree.new
-      rbi << Const.new("C", "42")
-      rbi << Module.new("S1")
-      rbi << Class.new("S2")
-      rbi << SingletonClass.new
-      rbi << Struct.new("S3")
-      rbi << Method.new("m1")
-      rbi << Method.new("m2", is_singleton: true)
-      rbi << Extend.new("E")
-      rbi << Include.new("I")
-      rbi << MixesInClassMethods.new("MICM")
-      rbi << RequiresAncestor.new("RA")
-      rbi << Helper.new("h")
-      rbi << TStructConst.new("SC", "Type")
-      rbi << TStructProp.new("SP", "Type")
-      rbi << TEnum.new("TE")
-      rbi << TStruct.new("TS")
-      rbi << Send.new("foo")
+      tree = parse_rbi(<<~RBI)
+        C = 42
+        module S1; end
+        class S2; end
+        class << self; end
+        S3 = ::Struct.new
+        def m1; end
+        def self.m2; end
+        extend E
+        include I
+        mixes_in_class_methods MICM
+        requires_ancestor { RA }
+        abstract!
+        const :SC, Type
+        prop :SP, Type
+        class TE < ::T::Enum; end
+        class TS < ::T::Struct; end
+        foo
+      RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         extend E
         include I
 
         requires_ancestor { RA }
 
-        h!
+        abstract!
 
         mixes_in_class_methods MICM
 
@@ -177,18 +180,19 @@ class TS < T::Struct; end
     end
 
     def test_group_does_not_sort_mixins
-      rbi = Tree.new
-      rbi << Include.new("I2")
-      rbi << Extend.new("E2")
-      rbi << MixesInClassMethods.new("M2")
-      rbi << Include.new("I1")
-      rbi << Extend.new("E1")
-      rbi << MixesInClassMethods.new("M1")
+      tree = parse_rbi(<<~RBI)
+        include I2
+        extend E2
+        mixes_in_class_methods M2
+        include I1
+        extend E1
+        mixes_in_class_methods M1
+      RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         include I2
         extend E2
         include I1
@@ -200,16 +204,17 @@ def test_group_does_not_sort_mixins
     end
 
     def test_group_does_not_sort_sends
-      rbi = Tree.new
-      rbi << Send.new("send4")
-      rbi << Send.new("send2")
-      rbi << Send.new("send3")
-      rbi << Send.new("send1")
+      tree = parse_rbi(<<~RBI)
+        send4
+        send2
+        send3
+        send1
+      RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         send4
         send2
         send3
@@ -218,16 +223,17 @@ def test_group_does_not_sort_sends
     end
 
     def test_group_does_not_sort_type_members
-      rbi = Tree.new
-      rbi << TypeMember.new("T4", "type_member")
-      rbi << TypeMember.new("T3", "type_template")
-      rbi << TypeMember.new("T2", "type_member")
-      rbi << TypeMember.new("T1", "type_template")
+      tree = parse_rbi(<<~RBI)
+        T4 = type_member
+        T3 = type_template
+        T2 = type_member
+        T1 = type_template
+      RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         T4 = type_member
         T3 = type_template
         T2 = type_member
@@ -236,41 +242,42 @@ def test_group_does_not_sort_type_members
     end
 
     def test_group_sort_nodes_in_scope
-      rbi = Tree.new
-      scope = Module.new("Scope")
-      scope << Const.new("C", "42")
-      scope << SingletonClass.new
-      scope << Module.new("S1")
-      scope << Class.new("S2")
-      scope << Struct.new("S3")
-      scope << Method.new("m1")
-      scope << Method.new("m2", is_singleton: true)
-      scope << Include.new("I")
-      scope << Extend.new("E")
-      scope << MixesInClassMethods.new("MICM")
-      scope << RequiresAncestor.new("RA")
-      scope << Helper.new("h")
-      scope << TStructProp.new("SP", "Type")
-      scope << TStructConst.new("SC", "Type")
-      scope << TEnum.new("TE")
-      scope << TStruct.new("TS")
-      scope << TypeMember.new("TM2", "type_template")
-      scope << TypeMember.new("TM1", "type_member")
-      scope << Send.new("send2")
-      scope << Send.new("send1")
-      rbi << scope
+      tree = parse_rbi(<<~RBI)
+        module Scope
+          C = 42
+          class << self; end
+          module S1; end
+          class S2; end
+          S3 = ::Struct.new
+          def m1; end
+          def self.m2; end
+          include I
+          extend E
+          mixes_in_class_methods MICM
+          requires_ancestor { RA }
+          abstract!
+          prop :SP, Type
+          const :SC, Type
+          class TE < ::T::Enum; end
+          class TS < ::T::Struct; end
+          TM2 = type_template
+          TM1 = type_member
+          send2
+          send1
+        end
+      RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         module Scope
           include I
           extend E
 
           requires_ancestor { RA }
 
-          h!
+          abstract!
 
           TM2 = type_template
           TM1 = type_member
@@ -299,40 +306,41 @@ class TS < T::Struct; end
     end
 
     def test_group_sort_groups_in_tree
-      rbi = Tree.new
-      rbi << Const.new("C2", "42")
-      rbi << SingletonClass.new
-      rbi << Module.new("S2")
-      rbi << Method.new("m2")
-      rbi << Include.new("I2")
-      rbi << Extend.new("E2")
-      rbi << MixesInClassMethods.new("MICM2")
-      rbi << RequiresAncestor.new("RA2")
-      rbi << Helper.new("h2")
-      rbi << TStructProp.new("SP2", "Type")
-      rbi << TStructConst.new("SC2", "Type")
-      rbi << TEnum.new("TE2")
-      rbi << TStruct.new("TS2")
-      rbi << Const.new("C1", "42")
-      rbi << Class.new("S1")
-      rbi << Method.new("m1")
-      rbi << Include.new("I1")
-      rbi << Extend.new("E1")
-      rbi << MixesInClassMethods.new("MICM1")
-      rbi << RequiresAncestor.new("RA1")
-      rbi << Helper.new("h1")
-      rbi << TStructProp.new("SP1", "Type")
-      rbi << TStructConst.new("SC1", "Type")
-      rbi << TEnum.new("TE1")
-      rbi << TStruct.new("TS1")
-      rbi << Struct.new("S3")
-      rbi << TypeMember.new("TM2", "type_template")
-      rbi << TypeMember.new("TM1", "type_member")
+      tree = parse_rbi(<<~RBI)
+        C2 = 42
+        class << self; end
+        module S2; end
+        def m2; end
+        include I2
+        extend E2
+        mixes_in_class_methods MICM2
+        requires_ancestor { RA2 }
+        sealed!
+        prop :SP2, Type
+        const :SC2, Type
+        class TE2 < ::T::Enum; end
+        class TS2 < ::T::Struct; end
+        C1 = 42
+        class S1; end
+        def m1; end
+        include I1
+        extend E1
+        mixes_in_class_methods MICM1
+        requires_ancestor { RA1 }
+        abstract!
+        prop :SP1, Type
+        const :SC1, Type
+        class TE1 < ::T::Enum; end
+        class TS1 < ::T::Struct; end
+        S3 = ::Struct.new
+        TM2 = type_template
+        TM1 = type_member
+      RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         include I2
         extend E2
         include I1
@@ -341,8 +349,8 @@ def test_group_sort_groups_in_tree
         requires_ancestor { RA1 }
         requires_ancestor { RA2 }
 
-        h1!
-        h2!
+        abstract!
+        sealed!
 
         TM2 = type_template
         TM1 = type_member
@@ -374,7 +382,6 @@ class TS2 < T::Struct; end
 
     def test_group_sort_nested_groups
       rbi = Tree.new
-
       sscope = Class.new("Scope2.1")
       sscope << Const.new("C2", "42")
       sscope << Module.new("S2")
@@ -584,15 +591,16 @@ class TS2 < T::Struct; end
     end
 
     def test_group_groups
-      rbi = Tree.new
-      rbi << Method.new("m")
-      rbi << Include.new("I")
-      rbi << AttrWriter.new(:a)
+      tree = parse_rbi(<<~RBI)
+        def m; end
+        include I
+        attr_writer :a
+      RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         include I
 
         attr_writer :a
@@ -600,10 +608,10 @@ def test_group_groups
         def m; end
       RBI
 
-      rbi.group_nodes!
-      rbi.sort_nodes!
+      tree.group_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         include I
 
         attr_writer :a
diff --git a/test/rbi/rewriters/nest_non_public_methods_test.rb b/test/rbi/rewriters/nest_non_public_methods_test.rb
index f8ee6e32..847ccb1e 100644
--- a/test/rbi/rewriters/nest_non_public_methods_test.rb
+++ b/test/rbi/rewriters/nest_non_public_methods_test.rb
@@ -5,16 +5,19 @@
 
 module RBI
   class NestNonPublicMethodsTest < Minitest::Test
+    include TestHelper
+
     def test_nest_non_public_methods_in_tree
-      rbi = Tree.new
-      rbi << Method.new("m1")
-      rbi << Method.new("m2", visibility: Protected.new)
-      rbi << Method.new("m3", visibility: Private.new)
-      rbi << Method.new("m4", visibility: Public.new)
+      tree = parse_rbi(<<~RBI)
+        def m1; end
+        protected def m2; end
+        private def m3; end
+        public def m4; end
+      RBI
 
-      rbi.nest_non_public_methods!
+      tree.nest_non_public_methods!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         def m1; end
         def m4; end
 
@@ -29,23 +32,26 @@ def m3; end
     end
 
     def test_nest_non_public_methods_in_scopes
-      rbi = Tree.new
-      scope1 = Module.new("S1")
-      scope1 << Method.new("m1")
-      scope1 << Method.new("m2", visibility: Protected.new)
-      scope2 = Class.new("S2")
-      scope2 << Method.new("m3")
-      scope2 << Method.new("m4", visibility: Private.new)
-      scope3 = SingletonClass.new
-      scope3 << Method.new("m5")
-      scope3 << Method.new("m6", visibility: Protected.new)
-      rbi << scope1
-      scope1 << scope2
-      scope2 << scope3
-
-      rbi.nest_non_public_methods!
-
-      assert_equal(<<~RBI, rbi.string)
+      tree = parse_rbi(<<~RBI)
+        module S1
+          def m1; end
+          protected def m2; end
+
+          class S2
+            def m3; end
+            private def m4; end
+
+            class << self
+              def m5; end
+              protected def m6; end
+            end
+          end
+        end
+      RBI
+
+      tree.nest_non_public_methods!
+
+      assert_equal(<<~RBI, tree.string)
         module S1
           class S2
             class << self
@@ -73,14 +79,15 @@ def m2; end
     end
 
     def test_nest_non_public_singleton_methods
-      rbi = Tree.new
-      rbi << Method.new("m1", is_singleton: true, visibility: Protected.new)
-      rbi << Method.new("m2", is_singleton: true, visibility: Private.new)
-      rbi << Method.new("m3", is_singleton: true, visibility: Public.new)
+      tree = parse_rbi(<<~RBI)
+        protected def self.m1; end
+        private def self.m2; end
+        public def self.m3; end
+      RBI
 
-      rbi.nest_non_public_methods!
+      tree.nest_non_public_methods!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         def self.m3; end
 
         protected
diff --git a/test/rbi/rewriters/nest_singleton_methods_test.rb b/test/rbi/rewriters/nest_singleton_methods_test.rb
index eefffecb..bdec4b4c 100644
--- a/test/rbi/rewriters/nest_singleton_methods_test.rb
+++ b/test/rbi/rewriters/nest_singleton_methods_test.rb
@@ -5,16 +5,19 @@
 
 module RBI
   class NestSingletonMethodsTest < Minitest::Test
+    include TestHelper
+
     def test_nest_singleton_methods_in_trees
-      rbi = Tree.new
-      rbi << Method.new("m1")
-      rbi << Method.new("m2", is_singleton: true)
-      rbi << Method.new("m3")
-      rbi << Method.new("m4", is_singleton: true)
+      tree = parse_rbi(<<~RBI)
+        def m1; end
+        def self.m2; end
+        def m3; end
+        def self.m4; end
+      RBI
 
-      rbi.nest_singleton_methods!
+      tree.nest_singleton_methods!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         def m1; end
         def m3; end
 
@@ -26,19 +29,21 @@ def m4; end
     end
 
     def test_nest_singleton_methods_in_scopes
-      rbi = Tree.new
-      scope1 = Module.new("Foo")
-      scope1 << Method.new("m1")
-      scope1 << Method.new("m2", is_singleton: true)
-      scope2 = Class.new("Bar")
-      scope2 << Method.new("m3")
-      scope2 << Method.new("m4", is_singleton: true)
-      rbi << scope1
-      rbi << scope2
-
-      rbi.nest_singleton_methods!
-
-      assert_equal(<<~RBI, rbi.string)
+      tree = parse_rbi(<<~RBI)
+        module Foo
+          def m1; end
+          def self.m2; end
+        end
+
+        class Bar
+          def m3; end
+          def self.m4; end
+        end
+      RBI
+
+      tree.nest_singleton_methods!
+
+      assert_equal(<<~RBI, tree.string)
         module Foo
           def m1; end
 
@@ -58,17 +63,18 @@ def m4; end
     end
 
     def test_nest_singleton_methods_in_singleton_classes
-      rbi = Tree.new
-      scope1 = SingletonClass.new
-      scope1 << Method.new("m1", is_singleton: true)
-      scope2 = SingletonClass.new
-      scope2 << Method.new("m2", is_singleton: true)
-      scope1 << scope2
-      rbi << scope1
+      tree = parse_rbi(<<~RBI)
+        class << self
+          def self.m1; end
+          class << self
+            def self.m2; end
+          end
+        end
+      RBI
 
-      rbi.nest_singleton_methods!
+      tree.nest_singleton_methods!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         class << self
           class << self
             class << self
@@ -84,20 +90,7 @@ def m1; end
     end
 
     def test_nest_does_not_nest_other_nodes
-      rbi = Tree.new
-      scope1 = Module.new("Foo")
-      scope1 << Const.new("C1", "42")
-      scope1 << Module.new("M1")
-      scope1 << Helper.new("h1")
-      scope2 = Class.new("Bar")
-      scope2 << Include.new("I1")
-      scope2 << Extend.new("E1")
-      rbi << scope1
-      rbi << scope2
-
-      rbi.nest_singleton_methods!
-
-      assert_equal(<<~RBI, rbi.string)
+      rbi = <<~RBI
         module Foo
           C1 = 42
           module M1; end
@@ -109,6 +102,11 @@ class Bar
           extend E1
         end
       RBI
+
+      tree = parse_rbi(rbi)
+      tree.nest_singleton_methods!
+
+      assert_equal(rbi, tree.string)
     end
   end
 end
diff --git a/test/rbi/rewriters/sort_nodes_test.rb b/test/rbi/rewriters/sort_nodes_test.rb
index 9682d167..557099ac 100644
--- a/test/rbi/rewriters/sort_nodes_test.rb
+++ b/test/rbi/rewriters/sort_nodes_test.rb
@@ -5,15 +5,18 @@
 
 module RBI
   class SortNodesSpec < Minitest::Test
+    include TestHelper
+
     def test_sorts_constants
-      rbi = Tree.new
-      rbi << Const.new("C", "42")
-      rbi << Const.new("B", "42")
-      rbi << Const.new("A", "42")
+      tree = parse_rbi(<<~RBI)
+        C = 42
+        B = 42
+        A = 42
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         A = 42
         B = 42
         C = 42
@@ -21,14 +24,15 @@ def test_sorts_constants
     end
 
     def test_sort_modules
-      rbi = Tree.new
-      rbi << Module.new("C")
-      rbi << Module.new("B")
-      rbi << Module.new("A")
+      tree = parse_rbi(<<~RBI)
+        module C; end
+        module B; end
+        module A; end
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         module A; end
         module B; end
         module C; end
@@ -36,14 +40,15 @@ module C; end
     end
 
     def test_sort_classes
-      rbi = Tree.new
-      rbi << Class.new("C")
-      rbi << Class.new("B")
-      rbi << Class.new("A")
+      tree = parse_rbi(<<~RBI)
+        class C; end
+        class B; end
+        class A; end
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         class A; end
         class B; end
         class C; end
@@ -51,14 +56,15 @@ class C; end
     end
 
     def test_sort_structs
-      rbi = Tree.new
-      rbi << Struct.new("C")
-      rbi << Struct.new("B")
-      rbi << Struct.new("A")
+      tree = parse_rbi(<<~RBI)
+        C = ::Struct.new
+        B = ::Struct.new
+        A = ::Struct.new
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         A = ::Struct.new
         B = ::Struct.new
         C = ::Struct.new
@@ -66,17 +72,18 @@ def test_sort_structs
     end
 
     def test_sort_constants_and_keeps_original_order_in_case_of_conflicts
-      rbi = Tree.new
-      rbi << Class.new("B")
-      rbi << Module.new("B")
-      rbi << Const.new("B", "42")
-      rbi << Const.new("A", "42")
-      rbi << Module.new("A")
-      rbi << Class.new("A")
+      tree = parse_rbi(<<~RBI)
+        class B; end
+        module B; end
+        B = 42
+        A = 42
+        module A; end
+        class A; end
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         A = 42
         module A; end
         class A; end
@@ -87,15 +94,16 @@ module B; end
     end
 
     def test_sort_methods
-      rbi = Tree.new
-      rbi << Method.new("m4")
-      rbi << Method.new("m3", is_singleton: true)
-      rbi << Method.new("m2", is_singleton: true)
-      rbi << Method.new("m1")
+      tree = parse_rbi(<<~RBI)
+        def m4; end
+        def self.m3; end
+        def self.m2; end
+        def m1; end
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         def m1; end
         def m4; end
         def self.m2; end
@@ -104,17 +112,18 @@ def self.m3; end
     end
 
     def test_sort_does_not_sort_mixins
-      rbi = Tree.new
-      rbi << MixesInClassMethods.new("E")
-      rbi << Extend.new("D")
-      rbi << Include.new("C")
-      rbi << Extend.new("B")
-      rbi << Include.new("A")
-      rbi << RequiresAncestor.new("A")
+      tree = parse_rbi(<<~RBI)
+        mixes_in_class_methods E
+        extend D
+        include C
+        extend B
+        include A
+        requires_ancestor { A }
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         extend D
         include C
         extend B
@@ -125,15 +134,16 @@ def test_sort_does_not_sort_mixins
     end
 
     def test_does_not_sort_sends
-      rbi = Tree.new
-      rbi << Send.new("send4")
-      rbi << Send.new("send2")
-      rbi << Send.new("send3")
-      rbi << Send.new("send1")
+      tree = parse_rbi(<<~RBI)
+        send4
+        send2
+        send3
+        send1
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         send4
         send2
         send3
@@ -142,30 +152,32 @@ def test_does_not_sort_sends
     end
 
     def test_sort_helpers_test
-      rbi = Tree.new
-      rbi << Helper.new("c")
-      rbi << Helper.new("b")
-      rbi << Helper.new("a")
+      tree = parse_rbi(<<~RBI)
+        sealed!
+        abstract!
+        interface!
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
-        a!
-        b!
-        c!
+      assert_equal(<<~RBI, tree.string)
+        abstract!
+        interface!
+        sealed!
       RBI
     end
 
     def test_sort_struct_properties
-      rbi = Tree.new
-      rbi << TStructConst.new("d", "T")
-      rbi << TStructProp.new("c", "T")
-      rbi << TStructConst.new("b", "T")
-      rbi << TStructProp.new("a", "T")
+      tree = parse_rbi(<<~RBI)
+        const :d, T
+        prop :c, T
+        const :b, T
+        prop :a, T
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         const :d, T
         prop :c, T
         const :b, T
@@ -174,15 +186,16 @@ def test_sort_struct_properties
     end
 
     def test_sort_tstructs
-      rbi = Tree.new
-      rbi << TStruct.new("D")
-      rbi << TStruct.new("C")
-      rbi << TStruct.new("B")
-      rbi << TStruct.new("A")
+      tree = parse_rbi(<<~RBI)
+        class D < ::T::Struct; end
+        class C < ::T::Struct; end
+        class B < ::T::Struct; end
+        class A < ::T::Struct; end
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         class A < T::Struct; end
         class B < T::Struct; end
         class C < T::Struct; end
@@ -191,15 +204,16 @@ class D < T::Struct; end
     end
 
     def test_sort_enums
-      rbi = Tree.new
-      rbi << TEnum.new("D")
-      rbi << TEnum.new("C")
-      rbi << TEnum.new("B")
-      rbi << TEnum.new("A")
+      tree = parse_rbi(<<~RBI)
+        class D < ::T::Enum; end
+        class C < ::T::Enum; end
+        class B < ::T::Enum; end
+        class A < ::T::Enum; end
+      RBI
 
-      rbi.sort_nodes!
+      tree.sort_nodes!
 
-      assert_equal(<<~RBI, rbi.string)
+      assert_equal(<<~RBI, tree.string)
         class A < T::Enum; end
         class B < T::Enum; end
         class C < T::Enum; end
@@ -208,34 +222,35 @@ class D < T::Enum; end
     end
 
     def test_sort_does_nothing_if_all_nodes_are_already_sorted
-      rbi = Tree.new
-      rbi << Extend.new("M4")
-      rbi << Include.new("M3")
-      rbi << Extend.new("M2")
-      rbi << Include.new("M1")
-      rbi << Helper.new("h")
-      rbi << MixesInClassMethods.new("MICM")
-      rbi << TStructProp.new("SP1", "T")
-      rbi << TStructConst.new("SP2", "T")
-      rbi << TStructProp.new("SP3", "T")
-      rbi << TStructConst.new("SP4", "T")
-      rbi << Method.new("m1")
-      rbi << Method.new("m2")
-      rbi << Method.new("m3", is_singleton: true)
-      rbi << Const.new("A", "42")
-      rbi << Module.new("B")
-      rbi << TEnum.new("C")
-      rbi << TStruct.new("D")
-      rbi << Class.new("E")
-
-      rbi.sort_nodes!
-
-      assert_equal(<<~RBI, rbi.string)
+      tree = parse_rbi(<<~RBI)
         extend M4
         include M3
         extend M2
         include M1
-        h!
+        abstract!
+        mixes_in_class_methods MICM
+        prop :SP1, T
+        const :SP2, T
+        prop :SP3, T
+        const :SP4, T
+        def m1; end
+        def m2; end
+        def self.m3; end
+        A = 42
+        module B; end
+        class C < T::Enum; end
+        class D < T::Struct; end
+        class E; end
+      RBI
+
+      tree.sort_nodes!
+
+      assert_equal(<<~RBI, tree.string)
+        extend M4
+        include M3
+        extend M2
+        include M1
+        abstract!
         mixes_in_class_methods MICM
         prop :SP1, T
         const :SP2, T
@@ -253,42 +268,43 @@ class E; end
     end
 
     def test_sort_all_nodes_in_tree
-      rbi = Tree.new
-      rbi << Const.new("A", "42")
-      rbi << Extend.new("M4")
-      rbi << Method.new("m1")
-      rbi << MixesInClassMethods.new("MICM")
-      rbi << Module.new("B")
-      rbi << SingletonClass.new
-      rbi << Include.new("M3")
-      rbi << TStructConst.new("SP2", "T")
-      rbi << Method.new("m2")
-      rbi << TStruct.new("D")
-      rbi << TEnum.new("C")
-      rbi << SingletonClass.new
-      rbi << Extend.new("M2")
-      rbi << TStructConst.new("SP4", "T")
-      rbi << Include.new("M1")
-      rbi << Helper.new("h")
-      rbi << SingletonClass.new
-      rbi << Class.new("E")
-      rbi << TStructProp.new("SP1", "T")
-      rbi << Method.new("m3", is_singleton: true)
-      rbi << TStructProp.new("SP3", "T")
-      rbi << AttrWriter.new(:baz, :b)
-      rbi << AttrReader.new(:bar)
-      rbi << AttrAccessor.new(:foo, :a, :z)
-      rbi << RequiresAncestor.new("RA")
-
-      rbi.sort_nodes!
-
-      assert_equal(<<~RBI, rbi.string)
+      tree = parse_rbi(<<~RBI)
+        A = 42
+        extend M4
+        def m1; end
+        mixes_in_class_methods MICM
+        module B; end
+        class << self; end
+        include M3
+        const :SP2, T
+        def m2; end
+        class D < T::Struct; end
+        class C < T::Enum; end
+        class << self; end
+        extend M2
+        const :SP4, T
+        include M1
+        abstract!
+        class << self; end
+        class E; end
+        prop :SP1, T
+        def self.m3; end
+        prop :SP3, T
+        attr_writer :baz, :b
+        attr_reader :bar
+        attr_accessor :foo, :a, :z
+        requires_ancestor { RA }
+      RBI
+
+      tree.sort_nodes!
+
+      assert_equal(<<~RBI, tree.string)
         extend M4
         include M3
         extend M2
         include M1
         requires_ancestor { RA }
-        h!
+        abstract!
         mixes_in_class_methods MICM
         const :SP2, T
         const :SP4, T
@@ -312,19 +328,20 @@ class E; end
     end
 
     def test_sort_doesnt_change_privacy
-      rbi = Tree.new
-      rbi << Public.new
-      rbi << Method.new("c") # 0
-      rbi << Private.new     # 1
-      rbi << Method.new("a") # 2
-      rbi << Protected.new   # 3
-      rbi << Method.new("b") # 4
-      rbi << Public.new
-      rbi << Method.new("aa")
-
-      rbi.sort_nodes!
-
-      assert_equal(<<~RBI, rbi.string)
+      tree = parse_rbi(<<~RBI)
+        public
+        def c; end
+        private
+        def a; end
+        protected
+        def b; end
+        public
+        def aa; end
+      RBI
+
+      tree.sort_nodes!
+
+      assert_equal(<<~RBI, tree.string)
         public
         def c; end
         private