Remove unused `DepthFirst` visitor

We only use `ToSQL` visitors in the our codebase, do not use
`DepthFirst` and `Dot` visitors.

The `DepthFirst` visitor (which was introduced at c86c37e5f) is used to
traverse an Arel (partial) ast with depth first.

Is there any worth to keep that undocumented feature with much code and
test cases.

This removes that unused `DepthFirst` code and test cases.

4 files changed, 7 insertions, 306 deletions

diff --git a/activerecord/test/cases/arel/nodes/node_test.rb b/activerecord/test/cases/arel/nodes/node_test.rb
index f4f07ef2c5..f1e0ce1ea9 100644
--- a/activerecord/test/cases/arel/nodes/node_test.rb
+++ b/activerecord/test/cases/arel/nodes/node_test.rb
@@ -18,24 +18,5 @@ module Arel
         assert klass.ancestors.include?(Nodes::Node), klass.name
       end
     end
-
-    def test_each
-      list = []
-      node = Nodes::Node.new
-      node.each { |n| list << n }
-      assert_equal [node], list
-    end
-
-    def test_generator
-      list = []
-      node = Nodes::Node.new
-      node.each.each { |n| list << n }
-      assert_equal [node], list
-    end
-
-    def test_enumerable
-      node = Nodes::Node.new
-      assert_kind_of Enumerable, node
-    end
   end
 end
diff --git a/activerecord/test/cases/arel/select_manager_test.rb b/activerecord/test/cases/arel/select_manager_test.rb
index e6c49cd429..526fe6787a 100644
--- a/activerecord/test/cases/arel/select_manager_test.rb
+++ b/activerecord/test/cases/arel/select_manager_test.rb
@@ -369,16 +369,6 @@ module Arel
         mgr = table.from
         assert mgr.ast
       end
-
-      it "should allow orders to work when the ast is grepped" do
-        table = Table.new :users
-        mgr = table.from
-        mgr.project Arel.sql "*"
-        mgr.from table
-        mgr.orders << Arel::Nodes::Ascending.new(Arel.sql("foo"))
-        mgr.ast.grep(Arel::Nodes::OuterJoin)
-        mgr.to_sql.must_be_like %{ SELECT * FROM "users" ORDER BY foo ASC }
-      end
     end
 
     describe "taken" do
diff --git a/activerecord/test/cases/arel/visitors/depth_first_test.rb b/activerecord/test/cases/arel/visitors/depth_first_test.rb
deleted file mode 100644
index 106be2311d..0000000000
--- a/activerecord/test/cases/arel/visitors/depth_first_test.rb
+++ /dev/null
@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../helper"
-
-module Arel
-  module Visitors
-    class TestDepthFirst < Arel::Test
-      Collector = Struct.new(:calls) do
-        def call(object)
-          calls << object
-        end
-      end
-
-      def setup
-        @collector = Collector.new []
-        @visitor = Visitors::DepthFirst.new @collector
-      end
-
-      def test_raises_with_object
-        assert_raises(TypeError) do
-          @visitor.accept(Object.new)
-        end
-      end
-
-
-      # unary ops
-      [
-        Arel::Nodes::Not,
-        Arel::Nodes::Group,
-        Arel::Nodes::On,
-        Arel::Nodes::Grouping,
-        Arel::Nodes::Offset,
-        Arel::Nodes::Ordering,
-        Arel::Nodes::StringJoin,
-        Arel::Nodes::UnqualifiedColumn,
-        Arel::Nodes::ValuesList,
-        Arel::Nodes::Limit,
-        Arel::Nodes::Else,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          op = klass.new(:a)
-          @visitor.accept op
-          assert_equal [:a, op], @collector.calls
-        end
-      end
-
-      # functions
-      [
-        Arel::Nodes::Exists,
-        Arel::Nodes::Avg,
-        Arel::Nodes::Min,
-        Arel::Nodes::Max,
-        Arel::Nodes::Sum,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          func = klass.new(:a, "b")
-          @visitor.accept func
-          assert_equal [:a, "b", false, func], @collector.calls
-        end
-      end
-
-      def test_named_function
-        func = Arel::Nodes::NamedFunction.new(:a, :b, "c")
-        @visitor.accept func
-        assert_equal [:a, :b, false, "c", func], @collector.calls
-      end
-
-      def test_lock
-        lock = Nodes::Lock.new true
-        @visitor.accept lock
-        assert_equal [lock], @collector.calls
-      end
-
-      def test_count
-        count = Nodes::Count.new :a, :b, "c"
-        @visitor.accept count
-        assert_equal [:a, "c", :b, count], @collector.calls
-      end
-
-      def test_inner_join
-        join = Nodes::InnerJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      def test_full_outer_join
-        join = Nodes::FullOuterJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      def test_outer_join
-        join = Nodes::OuterJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      def test_right_outer_join
-        join = Nodes::RightOuterJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      def test_comment
-        comment = Nodes::Comment.new ["foo"]
-        @visitor.accept comment
-        assert_equal ["foo", ["foo"], comment], @collector.calls
-      end
-
-      [
-        Arel::Nodes::Assignment,
-        Arel::Nodes::Between,
-        Arel::Nodes::Concat,
-        Arel::Nodes::DoesNotMatch,
-        Arel::Nodes::Equality,
-        Arel::Nodes::GreaterThan,
-        Arel::Nodes::GreaterThanOrEqual,
-        Arel::Nodes::In,
-        Arel::Nodes::LessThan,
-        Arel::Nodes::LessThanOrEqual,
-        Arel::Nodes::Matches,
-        Arel::Nodes::NotEqual,
-        Arel::Nodes::NotIn,
-        Arel::Nodes::Or,
-        Arel::Nodes::TableAlias,
-        Arel::Nodes::As,
-        Arel::Nodes::DeleteStatement,
-        Arel::Nodes::JoinSource,
-        Arel::Nodes::When,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new(:a, :b)
-          @visitor.accept binary
-          assert_equal [:a, :b, binary], @collector.calls
-        end
-      end
-
-      def test_Arel_Nodes_InfixOperation
-        binary = Arel::Nodes::InfixOperation.new(:o, :a, :b)
-        @visitor.accept binary
-        assert_equal [:a, :b, binary], @collector.calls
-      end
-
-      # N-ary
-      [
-        Arel::Nodes::And,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new([:a, :b, :c])
-          @visitor.accept binary
-          assert_equal [:a, :b, :c, binary], @collector.calls
-        end
-      end
-
-      [
-        Arel::Attributes::Integer,
-        Arel::Attributes::Float,
-        Arel::Attributes::String,
-        Arel::Attributes::Time,
-        Arel::Attributes::Boolean,
-        Arel::Attributes::Attribute
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new(:a, :b)
-          @visitor.accept binary
-          assert_equal [:a, :b, binary], @collector.calls
-        end
-      end
-
-      def test_table
-        relation = Arel::Table.new(:users)
-        @visitor.accept relation
-        assert_equal ["users", relation], @collector.calls
-      end
-
-      def test_array
-        node = Nodes::Or.new(:a, :b)
-        list = [node]
-        @visitor.accept list
-        assert_equal [:a, :b, node, list], @collector.calls
-      end
-
-      def test_set
-        node = Nodes::Or.new(:a, :b)
-        set  = Set.new([node])
-        @visitor.accept set
-        assert_equal [:a, :b, node, set], @collector.calls
-      end
-
-      def test_hash
-        node = Nodes::Or.new(:a, :b)
-        hash = { node => node }
-        @visitor.accept hash
-        assert_equal [:a, :b, node, :a, :b, node, hash], @collector.calls
-      end
-
-      def test_update_statement
-        stmt = Nodes::UpdateStatement.new
-        stmt.relation = :a
-        stmt.values << :b
-        stmt.wheres << :c
-        stmt.orders << :d
-        stmt.limit = :e
-
-        @visitor.accept stmt
-        assert_equal [:a, :b, stmt.values, :c, stmt.wheres, :d, stmt.orders,
-          :e, stmt], @collector.calls
-      end
-
-      def test_select_core
-        core = Nodes::SelectCore.new
-        core.projections << :a
-        core.froms = :b
-        core.wheres << :c
-        core.groups << :d
-        core.windows << :e
-        core.havings << :f
-
-        @visitor.accept core
-        assert_equal [
-          :a, core.projections,
-          :b, [],
-          core.source,
-          :c, core.wheres,
-          :d, core.groups,
-          :e, core.windows,
-          :f, core.havings,
-          core], @collector.calls
-      end
-
-      def test_select_statement
-        ss = Nodes::SelectStatement.new
-        ss.cores.replace [:a]
-        ss.orders << :b
-        ss.limit = :c
-        ss.lock = :d
-        ss.offset = :e
-
-        @visitor.accept ss
-        assert_equal [
-          :a, ss.cores,
-          :b, ss.orders,
-          :c,
-          :d,
-          :e,
-          ss], @collector.calls
-      end
-
-      def test_insert_statement
-        stmt = Nodes::InsertStatement.new
-        stmt.relation = :a
-        stmt.columns << :b
-        stmt.values = :c
-
-        @visitor.accept stmt
-        assert_equal [:a, :b, stmt.columns, :c, stmt], @collector.calls
-      end
-
-      def test_case
-        node = Arel::Nodes::Case.new
-        node.case = :a
-        node.conditions << :b
-        node.default = :c
-
-        @visitor.accept node
-        assert_equal [:a, :b, node.conditions, :c, node], @collector.calls
-      end
-
-      def test_node
-        node = Nodes::Node.new
-        @visitor.accept node
-        assert_equal [node], @collector.calls
-      end
-    end
-  end
-end
diff --git a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
index a07a1a050a..36f9eb49a2 100644
--- a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
+++ b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
@@ -48,7 +48,13 @@ module Arel
         node = Nodes::Union.new(Nodes::True.new, Nodes::False.new)
         assert_equal "( TRUE UNION FALSE )", node.to_sql
 
-        node.first # from Nodes::Node's Enumerable mixin
+        visitor = Class.new(Visitor) {
+          def visit_Arel_Nodes_Union(o); end
+          alias :visit_Arel_Nodes_True  :visit_Arel_Nodes_Union
+          alias :visit_Arel_Nodes_False :visit_Arel_Nodes_Union
+        }.new
+
+        visitor.accept(node)
 
         assert_equal "( TRUE UNION FALSE )", node.to_sql
       end