From c52df44784308e5d3cd608566fd9a3514ce28959 Mon Sep 17 00:00:00 2001
From: Alex Lin <ww2lin@gmail.com>
Date: Mon, 24 Mar 2014 23:42:27 -0400
Subject: Removed all the fiels in lib/arel/visitors/ which needs dependency on
 'a' also fixed the test case for : test/visitors/test_to_sql.rb:22 which pass
 in the parameter attribute e.g the parameter a.

---
 lib/arel/visitors/bind_visitor.rb  |   6 +-
 lib/arel/visitors/depth_first.rb   | 112 ++++++-------
 lib/arel/visitors/dot.rb           | 148 ++++++++---------
 lib/arel/visitors/ibm_db.rb        |   4 +-
 lib/arel/visitors/informix.rb      |  32 ++--
 lib/arel/visitors/join_sql.rb      |   4 +-
 lib/arel/visitors/mssql.rb         |  24 +--
 lib/arel/visitors/mysql.rb         |  30 ++--
 lib/arel/visitors/oracle.rb        |  30 ++--
 lib/arel/visitors/order_clauses.rb |   4 +-
 lib/arel/visitors/postgresql.rb    |  14 +-
 lib/arel/visitors/sqlite.rb        |   4 +-
 lib/arel/visitors/to_sql.rb        | 329 ++++++++++++++++++-------------------
 lib/arel/visitors/visitor.rb       |   2 +-
 lib/arel/visitors/where_sql.rb     |   4 +-
 15 files changed, 367 insertions(+), 380 deletions(-)

(limited to 'lib')

diff --git a/lib/arel/visitors/bind_visitor.rb b/lib/arel/visitors/bind_visitor.rb
index 77b3f8237b..5cb251ffde 100644
--- a/lib/arel/visitors/bind_visitor.rb
+++ b/lib/arel/visitors/bind_visitor.rb
@@ -13,15 +13,15 @@ module Arel
 
       private
 
-      def visit_Arel_Nodes_Assignment o, a
+      def visit_Arel_Nodes_Assignment o
         if o.right.is_a? Arel::Nodes::BindParam
-          "#{visit o.left, a} = #{visit o.right, a}"
+          "#{visit o.left} = #{visit o.right}"
         else
           super
         end
       end
 
-      def visit_Arel_Nodes_BindParam o, a
+      def visit_Arel_Nodes_BindParam o
         if @block
           @block.call
         else
diff --git a/lib/arel/visitors/depth_first.rb b/lib/arel/visitors/depth_first.rb
index 18bd81fb9c..1770ab21d5 100644
--- a/lib/arel/visitors/depth_first.rb
+++ b/lib/arel/visitors/depth_first.rb
@@ -7,13 +7,13 @@ module Arel
 
       private
 
-      def visit o, a = nil
+      def visit o
         super
         @block.call o
       end
 
-      def unary o, a
-        visit o.expr, a
+      def unary o
+        visit o.expr
       end
       alias :visit_Arel_Nodes_Group             :unary
       alias :visit_Arel_Nodes_Grouping          :unary
@@ -28,10 +28,10 @@ module Arel
       alias :visit_Arel_Nodes_Top               :unary
       alias :visit_Arel_Nodes_UnqualifiedColumn :unary
 
-      def function o, a
-        visit o.expressions, a
-        visit o.alias, a
-        visit o.distinct, a
+      def function o
+        visit o.expressions
+        visit o.alias
+        visit o.distinct
       end
       alias :visit_Arel_Nodes_Avg    :function
       alias :visit_Arel_Nodes_Exists :function
@@ -39,27 +39,27 @@ module Arel
       alias :visit_Arel_Nodes_Min    :function
       alias :visit_Arel_Nodes_Sum    :function
 
-      def visit_Arel_Nodes_NamedFunction o, a
-        visit o.name, a
-        visit o.expressions, a
-        visit o.distinct, a
-        visit o.alias, a
+      def visit_Arel_Nodes_NamedFunction o
+        visit o.name
+        visit o.expressions
+        visit o.distinct
+        visit o.alias
       end
 
-      def visit_Arel_Nodes_Count o, a
-        visit o.expressions, a
-        visit o.alias, a
-        visit o.distinct, a
+      def visit_Arel_Nodes_Count o
+        visit o.expressions
+        visit o.alias
+        visit o.distinct
       end
 
-      def nary o, a
-        o.children.each { |child| visit child, a }
+      def nary o
+        o.children.each { |child| visit child}
       end
       alias :visit_Arel_Nodes_And :nary
 
-      def binary o, a
-        visit o.left, a
-        visit o.right, a
+      def binary o
+        visit o.left
+        visit o.right
       end
       alias :visit_Arel_Nodes_As                 :binary
       alias :visit_Arel_Nodes_Assignment         :binary
@@ -83,13 +83,13 @@ module Arel
       alias :visit_Arel_Nodes_TableAlias         :binary
       alias :visit_Arel_Nodes_Values             :binary
 
-      def visit_Arel_Nodes_StringJoin o, a
-        visit o.left, a
+      def visit_Arel_Nodes_StringJoin o
+        visit o.left
       end
 
-      def visit_Arel_Attribute o, a
-        visit o.relation, a
-        visit o.name, a
+      def visit_Arel_Attribute o
+        visit o.relation
+        visit o.name
       end
       alias :visit_Arel_Attributes_Integer :visit_Arel_Attribute
       alias :visit_Arel_Attributes_Float :visit_Arel_Attribute
@@ -99,11 +99,11 @@ module Arel
       alias :visit_Arel_Attributes_Attribute :visit_Arel_Attribute
       alias :visit_Arel_Attributes_Decimal :visit_Arel_Attribute
 
-      def visit_Arel_Table o, a
-        visit o.name, a
+      def visit_Arel_Table o
+        visit o.name
       end
 
-      def terminal o, a
+      def terminal o
       end
       alias :visit_ActiveSupport_Multibyte_Chars :terminal
       alias :visit_ActiveSupport_StringInquirer  :terminal
@@ -126,43 +126,43 @@ module Arel
       alias :visit_Time                          :terminal
       alias :visit_TrueClass                     :terminal
 
-      def visit_Arel_Nodes_InsertStatement o, a
-        visit o.relation, a
-        visit o.columns, a
-        visit o.values, a
+      def visit_Arel_Nodes_InsertStatement o
+        visit o.relation
+        visit o.columns
+        visit o.values
       end
 
-      def visit_Arel_Nodes_SelectCore o, a
-        visit o.projections, a
-        visit o.source, a
-        visit o.wheres, a
-        visit o.groups, a
-        visit o.windows, a
-        visit o.having, a
+      def visit_Arel_Nodes_SelectCore o
+        visit o.projections
+        visit o.source
+        visit o.wheres
+        visit o.groups
+        visit o.windows
+        visit o.having
       end
 
-      def visit_Arel_Nodes_SelectStatement o, a
-        visit o.cores, a
-        visit o.orders, a
-        visit o.limit, a
-        visit o.lock, a
-        visit o.offset, a
+      def visit_Arel_Nodes_SelectStatement o
+        visit o.cores
+        visit o.orders
+        visit o.limit
+        visit o.lock
+        visit o.offset
       end
 
-      def visit_Arel_Nodes_UpdateStatement o, a
-        visit o.relation, a
-        visit o.values, a
-        visit o.wheres, a
-        visit o.orders, a
-        visit o.limit, a
+      def visit_Arel_Nodes_UpdateStatement o
+        visit o.relation
+        visit o.values
+        visit o.wheres
+        visit o.orders
+        visit o.limit
       end
 
-      def visit_Array o, a
-        o.each { |i| visit i, a }
+      def visit_Array o
+        o.each { |i| visit i }
       end
 
-      def visit_Hash o, a
-        o.each { |k,v| visit(k, a); visit(v, a) }
+      def visit_Hash o
+        o.each { |k,v| visit(k); visit(v) }
       end
     end
   end
diff --git a/lib/arel/visitors/dot.rb b/lib/arel/visitors/dot.rb
index cb4c2d494c..d5033d166d 100644
--- a/lib/arel/visitors/dot.rb
+++ b/lib/arel/visitors/dot.rb
@@ -28,41 +28,41 @@ module Arel
       end
 
       private
-      def visit_Arel_Nodes_Ordering o, a
-        visit_edge o, a, "expr"
+      def visit_Arel_Nodes_Ordering o
+        visit_edge o, "expr"
       end
 
-      def visit_Arel_Nodes_TableAlias o, a
-        visit_edge o, a, "name"
-        visit_edge o, a, "relation"
+      def visit_Arel_Nodes_TableAlias o
+        visit_edge o, "name"
+        visit_edge o, "relation"
       end
 
-      def visit_Arel_Nodes_Count o, a
-        visit_edge o, a, "expressions"
-        visit_edge o, a, "distinct"
+      def visit_Arel_Nodes_Count o
+        visit_edge o, "expressions"
+        visit_edge o, "distinct"
       end
 
-      def visit_Arel_Nodes_Values o, a
-        visit_edge o, a, "expressions"
+      def visit_Arel_Nodes_Values o
+        visit_edge o, "expressions"
       end
 
-      def visit_Arel_Nodes_StringJoin o, a
-        visit_edge o, a, "left"
+      def visit_Arel_Nodes_StringJoin o
+        visit_edge o, "left"
       end
 
-      def visit_Arel_Nodes_InnerJoin o, a
-        visit_edge o, a, "left"
-        visit_edge o, a, "right"
+      def visit_Arel_Nodes_InnerJoin o
+        visit_edge o, "left"
+        visit_edge o, "right"
       end
       alias :visit_Arel_Nodes_OuterJoin :visit_Arel_Nodes_InnerJoin
 
-      def visit_Arel_Nodes_DeleteStatement o, a
-        visit_edge o, a, "relation"
-        visit_edge o, a, "wheres"
+      def visit_Arel_Nodes_DeleteStatement o
+        visit_edge o, "relation"
+        visit_edge o, "wheres"
       end
 
-      def unary o, a
-        visit_edge o, a, "expr"
+      def unary o
+        visit_edge o, "expr"
       end
       alias :visit_Arel_Nodes_Group             :unary
       alias :visit_Arel_Nodes_Grouping          :unary
@@ -78,23 +78,23 @@ module Arel
       alias :visit_Arel_Nodes_Rows              :unary
       alias :visit_Arel_Nodes_Range             :unary
 
-      def window o, a
-        visit_edge o, a, "orders"
-        visit_edge o, a, "framing"
+      def window o
+        visit_edge o, "orders"
+        visit_edge o, "framing"
       end
       alias :visit_Arel_Nodes_Window            :window
 
-      def named_window o, a
-        visit_edge o, a, "orders"
-        visit_edge o, a, "framing"
-        visit_edge o, a, "name"
+      def named_window o
+        visit_edge o, "orders"
+        visit_edge o, "framing"
+        visit_edge o, "name"
       end
       alias :visit_Arel_Nodes_NamedWindow       :named_window
 
-      def function o, a
-        visit_edge o, a, "expressions"
-        visit_edge o, a, "distinct"
-        visit_edge o, a, "alias"
+      def function o
+        visit_edge o, "expressions"
+        visit_edge o, "distinct"
+        visit_edge o, "alias"
       end
       alias :visit_Arel_Nodes_Exists :function
       alias :visit_Arel_Nodes_Min    :function
@@ -102,52 +102,52 @@ module Arel
       alias :visit_Arel_Nodes_Avg    :function
       alias :visit_Arel_Nodes_Sum    :function
 
-      def extract o, a
-        visit_edge o, a, "expressions"
-        visit_edge o, a, "alias"
+      def extract o
+        visit_edge o, "expressions"
+        visit_edge o, "alias"
       end
       alias :visit_Arel_Nodes_Extract :extract
 
-      def visit_Arel_Nodes_NamedFunction o, a
-        visit_edge o, a, "name"
-        visit_edge o, a, "expressions"
-        visit_edge o, a, "distinct"
-        visit_edge o, a, "alias"
+      def visit_Arel_Nodes_NamedFunction o
+        visit_edge o, "name"
+        visit_edge o, "expressions"
+        visit_edge o, "distinct"
+        visit_edge o, "alias"
       end
 
-      def visit_Arel_Nodes_InsertStatement o, a
-        visit_edge o, a, "relation"
-        visit_edge o, a, "columns"
-        visit_edge o, a, "values"
+      def visit_Arel_Nodes_InsertStatement o
+        visit_edge o, "relation"
+        visit_edge o, "columns"
+        visit_edge o, "values"
       end
 
-      def visit_Arel_Nodes_SelectCore o, a
-        visit_edge o, a, "source"
-        visit_edge o, a, "projections"
-        visit_edge o, a, "wheres"
-        visit_edge o, a, "windows"
+      def visit_Arel_Nodes_SelectCore o
+        visit_edge o, "source"
+        visit_edge o, "projections"
+        visit_edge o, "wheres"
+        visit_edge o,  "windows"
       end
 
-      def visit_Arel_Nodes_SelectStatement o, a
-        visit_edge o, a, "cores"
-        visit_edge o, a, "limit"
-        visit_edge o, a, "orders"
-        visit_edge o, a, "offset"
+      def visit_Arel_Nodes_SelectStatement o
+        visit_edge o, "cores"
+        visit_edge o, "limit"
+        visit_edge o, "orders"
+        visit_edge o, "offset"
       end
 
-      def visit_Arel_Nodes_UpdateStatement o, a
-        visit_edge o, a, "relation"
-        visit_edge o, a, "wheres"
-        visit_edge o, a, "values"
+      def visit_Arel_Nodes_UpdateStatement o
+        visit_edge o, "relation"
+        visit_edge o, "wheres"
+        visit_edge o, "values"
       end
 
-      def visit_Arel_Table o, a
-        visit_edge o, a, "name"
+      def visit_Arel_Table o
+        visit_edge o, "name"
       end
 
-      def visit_Arel_Attribute o, a
-        visit_edge o, a, "relation"
-        visit_edge o, a, "name"
+      def visit_Arel_Attribute o
+        visit_edge o, "relation"
+        visit_edge o, "name"
       end
       alias :visit_Arel_Attributes_Integer :visit_Arel_Attribute
       alias :visit_Arel_Attributes_Float :visit_Arel_Attribute
@@ -156,16 +156,16 @@ module Arel
       alias :visit_Arel_Attributes_Boolean :visit_Arel_Attribute
       alias :visit_Arel_Attributes_Attribute :visit_Arel_Attribute
 
-      def nary o, a
+      def nary o
         o.children.each_with_index do |x,i|
-          edge(i) { visit x, a }
+          edge(i) { visit x }
         end
       end
       alias :visit_Arel_Nodes_And :nary
 
-      def binary o, a
-        visit_edge o, a, "left"
-        visit_edge o, a, "right"
+      def binary o
+        visit_edge o, "left"
+        visit_edge o, "right"
       end
       alias :visit_Arel_Nodes_As                 :binary
       alias :visit_Arel_Nodes_Assignment         :binary
@@ -184,7 +184,7 @@ module Arel
       alias :visit_Arel_Nodes_Or                 :binary
       alias :visit_Arel_Nodes_Over               :binary
 
-      def visit_String o, a
+      def visit_String o
         @node_stack.last.fields << o
       end
       alias :visit_Time :visit_String
@@ -200,23 +200,23 @@ module Arel
       alias :visit_Symbol :visit_String
       alias :visit_Arel_Nodes_SqlLiteral :visit_String
 
-      def visit_Hash o, a
+      def visit_Hash o
         o.each_with_index do |pair, i|
           edge("pair_#{i}")   { visit pair, a }
         end
       end
 
-      def visit_Array o, a
+      def visit_Array o
         o.each_with_index do |x,i|
-          edge(i) { visit x, a }
+          edge(i) { visit x }
         end
       end
 
-      def visit_edge o, a, method
-        edge(method) { visit o.send(method), a }
+      def visit_edge o, method
+        edge(method) { visit o.send(method) }
       end
 
-      def visit o, a = nil
+      def visit o = nil
         if node = @seen[o.object_id]
           @edge_stack.last.to = node
           return
diff --git a/lib/arel/visitors/ibm_db.rb b/lib/arel/visitors/ibm_db.rb
index 13af27df71..a41f8ff573 100644
--- a/lib/arel/visitors/ibm_db.rb
+++ b/lib/arel/visitors/ibm_db.rb
@@ -3,8 +3,8 @@ module Arel
     class IBM_DB < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_Limit o, a
-        "FETCH FIRST #{visit o.expr, a} ROWS ONLY"
+      def visit_Arel_Nodes_Limit o
+        "FETCH FIRST #{visit o.expr } ROWS ONLY"
       end
 
     end
diff --git a/lib/arel/visitors/informix.rb b/lib/arel/visitors/informix.rb
index a578119d9b..244c68bed3 100644
--- a/lib/arel/visitors/informix.rb
+++ b/lib/arel/visitors/informix.rb
@@ -2,30 +2,30 @@ module Arel
   module Visitors
     class Informix < Arel::Visitors::ToSql
       private
-      def visit_Arel_Nodes_SelectStatement o, a
+      def visit_Arel_Nodes_SelectStatement o
         [
           "SELECT",
-          (visit(o.offset, a) if o.offset),
-          (visit(o.limit, a) if o.limit),
-          o.cores.map { |x| visit_Arel_Nodes_SelectCore x, a }.join,
-          ("ORDER BY #{o.orders.map { |x| visit x, a }.join(', ')}" unless o.orders.empty?),
-          (visit(o.lock, a) if o.lock),
+          (visit(o.offset) if o.offset),
+          (visit(o.limit) if o.limit),
+          o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join,
+          ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
+          (visit(o.lock) if o.lock),
         ].compact.join ' '
       end
-      def visit_Arel_Nodes_SelectCore o, a
+      def visit_Arel_Nodes_SelectCore o
         [
-          "#{o.projections.map { |x| visit x, a }.join ', '}",
-          ("FROM #{visit(o.source, a)}" if o.source && !o.source.empty?),
-          ("WHERE #{o.wheres.map { |x| visit x, a }.join ' AND ' }" unless o.wheres.empty?),
-          ("GROUP BY #{o.groups.map { |x| visit x, a }.join ', ' }" unless o.groups.empty?),
-          (visit(o.having, a) if o.having),
+          "#{o.projections.map { |x| visit x }.join ', '}",
+          ("FROM #{visit(o.source)}" if o.source && !o.source.empty?),
+          ("WHERE #{o.wheres.map { |x| visit x }.join ' AND ' }" unless o.wheres.empty?),
+          ("GROUP BY #{o.groups.map { |x| visit x }.join ', ' }" unless o.groups.empty?),
+          (visit(o.having) if o.having),
         ].compact.join ' '
       end
-      def visit_Arel_Nodes_Offset o, a
-        "SKIP #{visit o.expr, a}"
+      def visit_Arel_Nodes_Offset o
+        "SKIP #{visit o.expr}"
       end
-      def visit_Arel_Nodes_Limit o, a
-        "LIMIT #{visit o.expr, a}"
+      def visit_Arel_Nodes_Limit o
+        "LIMIT #{visit o.expr}"
       end
     end
   end
diff --git a/lib/arel/visitors/join_sql.rb b/lib/arel/visitors/join_sql.rb
index 9708887075..1cdd7eb5ca 100644
--- a/lib/arel/visitors/join_sql.rb
+++ b/lib/arel/visitors/join_sql.rb
@@ -11,8 +11,8 @@ module Arel
     module JoinSql
       private
 
-      def visit_Arel_Nodes_SelectCore o, a
-        o.source.right.map { |j| visit j, a }.join ' '
+      def visit_Arel_Nodes_SelectCore o
+        o.source.right.map { |j| visit j }.join ' '
       end
     end
   end
diff --git a/lib/arel/visitors/mssql.rb b/lib/arel/visitors/mssql.rb
index 2f5edce19a..ef0b78058e 100644
--- a/lib/arel/visitors/mssql.rb
+++ b/lib/arel/visitors/mssql.rb
@@ -6,20 +6,20 @@ module Arel
       # `top` wouldn't really work here. I.e. User.select("distinct first_name").limit(10) would generate
       # "select top 10 distinct first_name from users", which is invalid query! it should be
       # "select distinct top 10 first_name from users"
-      def visit_Arel_Nodes_Top o, a
+      def visit_Arel_Nodes_Top o
         ""
       end
 
-      def visit_Arel_Nodes_SelectStatement o, a
+      def visit_Arel_Nodes_SelectStatement o
         if !o.limit && !o.offset
-          return super o, a
+          return super o
         end
 
-        select_order_by = "ORDER BY #{o.orders.map { |x| visit x, a }.join(', ')}" unless o.orders.empty?
+        select_order_by = "ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?
 
         is_select_count = false
         sql = o.cores.map { |x|
-          core_order_by = select_order_by || determine_order_by(x, a)
+          core_order_by = select_order_by || determine_order_by(x)
           if select_count? x
             x.projections = [row_num_literal(core_order_by)]
             is_select_count = true
@@ -27,7 +27,7 @@ module Arel
             x.projections << row_num_literal(core_order_by)
           end
 
-          visit_Arel_Nodes_SelectCore x, a
+          visit_Arel_Nodes_SelectCore x
         }.join
 
         sql = "SELECT _t.* FROM (#{sql}) as _t WHERE #{get_offset_limit_clause(o)}"
@@ -46,11 +46,11 @@ module Arel
         end
       end
 
-      def determine_order_by x, a
+      def determine_order_by x
         unless x.groups.empty?
-          "ORDER BY #{x.groups.map { |g| visit g, a }.join ', ' }"
+          "ORDER BY #{x.groups.map { |g| visit g }.join ', ' }"
         else
-          "ORDER BY #{find_left_table_pk(x.froms, a)}"
+          "ORDER BY #{find_left_table_pk(x.froms)}"
         end
       end
 
@@ -64,9 +64,9 @@ module Arel
 
       # FIXME raise exception of there is no pk?
       # FIXME!! Table.primary_key will be deprecated. What is the replacement??
-      def find_left_table_pk o, a
-        return visit o.primary_key, a if o.instance_of? Arel::Table
-        find_left_table_pk o.left, a if o.kind_of? Arel::Nodes::Join
+      def find_left_table_pk o
+        return visit o.primary_key if o.instance_of? Arel::Table
+        find_left_table_pk o.left if o.kind_of? Arel::Nodes::Join
       end
     end
   end
diff --git a/lib/arel/visitors/mysql.rb b/lib/arel/visitors/mysql.rb
index ec9d91f8ce..3b911e826f 100644
--- a/lib/arel/visitors/mysql.rb
+++ b/lib/arel/visitors/mysql.rb
@@ -2,19 +2,19 @@ module Arel
   module Visitors
     class MySQL < Arel::Visitors::ToSql
       private
-      def visit_Arel_Nodes_Union o, a, suppress_parens = false
+      def visit_Arel_Nodes_Union o, suppress_parens = false
         left_result = case o.left
                       when Arel::Nodes::Union
-                        visit_Arel_Nodes_Union o.left, a, true
+                        visit_Arel_Nodes_Union o.left, true
                       else
-                        visit o.left, a
+                        visit o.left
                       end
 
         right_result = case o.right
                        when Arel::Nodes::Union
-                         visit_Arel_Nodes_Union o.right, a, true
+                         visit_Arel_Nodes_Union o.right, true
                        else
-                         visit o.right, a
+                         visit o.right
                        end
 
         if suppress_parens
@@ -24,32 +24,32 @@ module Arel
         end
       end
 
-      def visit_Arel_Nodes_Bin o, a
-        "BINARY #{visit o.expr, a}"
+      def visit_Arel_Nodes_Bin o
+        "BINARY #{visit o.expr}"
       end
 
       ###
       # :'(
       # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
-      def visit_Arel_Nodes_SelectStatement o, a
+      def visit_Arel_Nodes_SelectStatement o
         if o.offset && !o.limit
           o.limit = Arel::Nodes::Limit.new(Nodes.build_quoted(18446744073709551615))
         end
         super
       end
 
-      def visit_Arel_Nodes_SelectCore o, a
+      def visit_Arel_Nodes_SelectCore o
         o.froms ||= Arel.sql('DUAL')
         super
       end
 
-      def visit_Arel_Nodes_UpdateStatement o, a
+      def visit_Arel_Nodes_UpdateStatement o
         [
-          "UPDATE #{visit o.relation, a}",
-          ("SET #{o.values.map { |value| visit value, a }.join ', '}" unless o.values.empty?),
-          ("WHERE #{o.wheres.map { |x| visit x, a }.join ' AND '}" unless o.wheres.empty?),
-          ("ORDER BY #{o.orders.map { |x| visit x, a }.join(', ')}" unless o.orders.empty?),
-          (visit(o.limit, a) if o.limit),
+          "UPDATE #{visit o.relation}",
+          ("SET #{o.values.map { |value| visit value }.join ', '}" unless o.values.empty?),
+          ("WHERE #{o.wheres.map { |x| visit x }.join ' AND '}" unless o.wheres.empty?),
+          ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
+          (visit(o.limit) if o.limit),
         ].compact.join ' '
       end
 
diff --git a/lib/arel/visitors/oracle.rb b/lib/arel/visitors/oracle.rb
index b6f7b4cc3c..0b5f19baa1 100644
--- a/lib/arel/visitors/oracle.rb
+++ b/lib/arel/visitors/oracle.rb
@@ -3,8 +3,8 @@ module Arel
     class Oracle < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_SelectStatement o, a
-        o = order_hacks(o, a)
+      def visit_Arel_Nodes_SelectStatement o
+        o = order_hacks(o)
 
         # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
         # then can use simple ROWNUM in WHERE clause
@@ -20,52 +20,52 @@ module Arel
           limit    = o.limit.expr.to_i
           offset   = o.offset
           o.offset = nil
-          sql = super(o, a)
+          sql = super(o)
           return <<-eosql
               SELECT * FROM (
                 SELECT raw_sql_.*, rownum raw_rnum_
                 FROM (#{sql}) raw_sql_
                 WHERE rownum <= #{offset.expr.to_i + limit}
               )
-              WHERE #{visit offset, a}
+              WHERE #{visit offset}
           eosql
         end
 
         if o.limit
           o       = o.dup
           limit   = o.limit.expr
-          return "SELECT * FROM (#{super(o, a)}) WHERE ROWNUM <= #{visit limit, a}"
+          return "SELECT * FROM (#{super(o)}) WHERE ROWNUM <= #{visit limit}"
         end
 
         if o.offset
           o        = o.dup
           offset   = o.offset
           o.offset = nil
-          sql = super(o, a)
+          sql = super(o)
           return <<-eosql
               SELECT * FROM (
                 SELECT raw_sql_.*, rownum raw_rnum_
                 FROM (#{sql}) raw_sql_
               )
-              WHERE #{visit offset, a}
+              WHERE #{visit offset}
           eosql
         end
 
         super
       end
 
-      def visit_Arel_Nodes_Limit o, a
+      def visit_Arel_Nodes_Limit o
       end
 
-      def visit_Arel_Nodes_Offset o, a
-        "raw_rnum_ > #{visit o.expr, a}"
+      def visit_Arel_Nodes_Offset o
+        "raw_rnum_ > #{visit o.expr}"
       end
 
-      def visit_Arel_Nodes_Except o, a
-        "( #{visit o.left, a} MINUS #{visit o.right, a} )"
+      def visit_Arel_Nodes_Except o
+        "( #{visit o.left } MINUS #{visit o.right} )"
       end
 
-      def visit_Arel_Nodes_UpdateStatement o, a
+      def visit_Arel_Nodes_UpdateStatement o
         # Oracle does not allow ORDER BY/LIMIT in UPDATEs.
         if o.orders.any? && o.limit.nil?
           # However, there is no harm in silently eating the ORDER BY clause if no LIMIT has been provided,
@@ -79,7 +79,7 @@ module Arel
 
       ###
       # Hacks for the order clauses specific to Oracle
-      def order_hacks o, a
+      def order_hacks o
         return o if o.orders.empty?
         return o unless o.cores.any? do |core|
           core.projections.any? do |projection|
@@ -91,7 +91,7 @@ module Arel
         #
         # orders   = o.orders.map { |x| visit x, a }.join(', ').split(',')
         orders   = o.orders.map do |x|
-          string = visit x, a
+          string = visit x
           if string.include?(',')
             split_order_string(string)
           else
diff --git a/lib/arel/visitors/order_clauses.rb b/lib/arel/visitors/order_clauses.rb
index b470d3f084..11dbfdad2a 100644
--- a/lib/arel/visitors/order_clauses.rb
+++ b/lib/arel/visitors/order_clauses.rb
@@ -3,8 +3,8 @@ module Arel
     class OrderClauses < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_SelectStatement o, a
-        o.orders.map { |x| visit x, a }
+      def visit_Arel_Nodes_SelectStatement o
+        o.orders.map { |x| visit x }
       end
     end
   end
diff --git a/lib/arel/visitors/postgresql.rb b/lib/arel/visitors/postgresql.rb
index 7520a1ccc7..812710181c 100644
--- a/lib/arel/visitors/postgresql.rb
+++ b/lib/arel/visitors/postgresql.rb
@@ -3,18 +3,16 @@ module Arel
     class PostgreSQL < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_Matches o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} ILIKE #{visit o.right, a}"
+      def visit_Arel_Nodes_Matches o
+        "#{visit o.left} ILIKE #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_DoesNotMatch o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} NOT ILIKE #{visit o.right, a}"
+      def visit_Arel_Nodes_DoesNotMatch o
+        "#{visit o.left} NOT ILIKE #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_DistinctOn o, a
-        "DISTINCT ON ( #{visit o.expr, a} )"
+      def visit_Arel_Nodes_DistinctOn o
+        "DISTINCT ON ( #{visit o.expr} )"
       end
     end
   end
diff --git a/lib/arel/visitors/sqlite.rb b/lib/arel/visitors/sqlite.rb
index 07a18fc2f5..2a509e95b5 100644
--- a/lib/arel/visitors/sqlite.rb
+++ b/lib/arel/visitors/sqlite.rb
@@ -4,10 +4,10 @@ module Arel
       private
 
       # Locks are not supported in SQLite
-      def visit_Arel_Nodes_Lock o, a
+      def visit_Arel_Nodes_Lock o
       end
 
-      def visit_Arel_Nodes_SelectStatement o, a
+      def visit_Arel_Nodes_SelectStatement o
         o.limit = Arel::Nodes::Limit.new(-1) if o.offset && !o.limit
         super
       end
diff --git a/lib/arel/visitors/to_sql.rb b/lib/arel/visitors/to_sql.rb
index 69c82e792a..0c2e649995 100644
--- a/lib/arel/visitors/to_sql.rb
+++ b/lib/arel/visitors/to_sql.rb
@@ -66,7 +66,7 @@ module Arel
 
       private
 
-      def visit_Arel_Nodes_DeleteStatement o, a
+      def visit_Arel_Nodes_DeleteStatement o
         [
           "DELETE FROM #{visit o.relation}",
           ("WHERE #{o.wheres.map { |x| visit x }.join AND}" unless o.wheres.empty?)
@@ -85,7 +85,7 @@ module Arel
         stmt
       end
 
-      def visit_Arel_Nodes_UpdateStatement o, a
+      def visit_Arel_Nodes_UpdateStatement o
         if o.orders.empty? && o.limit.nil?
           wheres = o.wheres
         else
@@ -93,42 +93,42 @@ module Arel
         end
 
         [
-          "UPDATE #{visit o.relation, a}",
-          ("SET #{o.values.map { |value| visit value, a }.join ', '}" unless o.values.empty?),
-          ("WHERE #{wheres.map { |x| visit x, a }.join ' AND '}" unless wheres.empty?),
+          "UPDATE #{visit o.relation}",
+          ("SET #{o.values.map { |value| visit value }.join ', '}" unless o.values.empty?),
+          ("WHERE #{wheres.map { |x| visit x }.join ' AND '}" unless wheres.empty?),
         ].compact.join ' '
       end
 
-      def visit_Arel_Nodes_InsertStatement o, a
+      def visit_Arel_Nodes_InsertStatement o
         [
-          "INSERT INTO #{visit o.relation, a}",
+          "INSERT INTO #{visit o.relation}",
 
           ("(#{o.columns.map { |x|
           quote_column_name x.name
         }.join ', '})" unless o.columns.empty?),
 
-          (visit o.values, a if o.values),
+          (visit o.values if o.values),
         ].compact.join ' '
       end
 
-      def visit_Arel_Nodes_Exists o, a
-        "EXISTS (#{visit o.expressions, a})#{
-          o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_Exists o
+        "EXISTS (#{visit o.expressions})#{
+          o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
-      def visit_Arel_Nodes_Casted o, a
+      def visit_Arel_Nodes_Casted o
         quoted o.val, o.attribute
       end
 
-      def visit_Arel_Nodes_Quoted o, a
+      def visit_Arel_Nodes_Quoted o
         quoted o.expr, nil
       end
 
-      def visit_Arel_Nodes_True o, a
+      def visit_Arel_Nodes_True o
         "TRUE"
       end
 
-      def visit_Arel_Nodes_False o, a
+      def visit_Arel_Nodes_False o
         "FALSE"
       end
 
@@ -150,66 +150,66 @@ module Arel
         @schema_cache.columns_hash(table)
       end
 
-      def visit_Arel_Nodes_Values o, a
+      def visit_Arel_Nodes_Values o
         "VALUES (#{o.expressions.zip(o.columns).map { |value, attr|
           if Nodes::SqlLiteral === value
-            visit value, a
+            visit value
           else
             quote(value, attr && column_for(attr))
           end
         }.join ', '})"
       end
 
-      def visit_Arel_Nodes_SelectStatement o, a
+      def visit_Arel_Nodes_SelectStatement o
         str = ''
 
         if o.with
-          str << visit(o.with, a)
+          str << visit(o.with)
           str << SPACE
         end
 
-        o.cores.each { |x| str << visit_Arel_Nodes_SelectCore(x, a) }
+        o.cores.each { |x| str << visit_Arel_Nodes_SelectCore(x) }
 
         unless o.orders.empty?
           str << SPACE
           str << ORDER_BY
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
-            str << visit(x, a)
+            str << visit(x)
             str << COMMA unless len == i
           }
         end
 
-        str << " #{visit(o.limit, a)}" if o.limit
-        str << " #{visit(o.offset, a)}" if o.offset
-        str << " #{visit(o.lock, a)}" if o.lock
+        str << " #{visit(o.limit)}" if o.limit
+        str << " #{visit(o.offset)}" if o.offset
+        str << " #{visit(o.lock)}" if o.lock
 
         str.strip!
         str
       end
 
-      def visit_Arel_Nodes_SelectCore o, a
+      def visit_Arel_Nodes_SelectCore o
         str = "SELECT"
 
-        str << " #{visit(o.top, a)}"            if o.top
-        str << " #{visit(o.set_quantifier, a)}" if o.set_quantifier
+        str << " #{visit(o.top)}"            if o.top
+        str << " #{visit(o.set_quantifier)}" if o.set_quantifier
 
         unless o.projections.empty?
           str << SPACE
           len = o.projections.length - 1
           o.projections.each_with_index do |x, i|
-            str << visit(x, a)
+            str << visit(x)
             str << COMMA unless len == i
           end
         end
 
-        str << " FROM #{visit(o.source, a)}" if o.source && !o.source.empty?
+        str << " FROM #{visit(o.source)}" if o.source && !o.source.empty?
 
         unless o.wheres.empty?
           str << WHERE
           len = o.wheres.length - 1
           o.wheres.each_with_index do |x, i|
-            str << visit(x, a)
+            str << visit(x)
             str << AND unless len == i
           end
         end
@@ -218,18 +218,18 @@ module Arel
           str << GROUP_BY
           len = o.groups.length - 1
           o.groups.each_with_index do |x, i|
-            str << visit(x, a)
+            str << visit(x)
             str << COMMA unless len == i
           end
         end
 
-        str << " #{visit(o.having, a)}" if o.having
+        str << " #{visit(o.having)}" if o.having
 
         unless o.windows.empty?
           str << WINDOW
           len = o.windows.length - 1
           o.windows.each_with_index do |x, i|
-            str << visit(x, a)
+            str << visit(x)
             str << COMMA unless len == i
           end
         end
@@ -237,244 +237,237 @@ module Arel
         str
       end
 
-      def visit_Arel_Nodes_Bin o, a
-        visit o.expr, a
+      def visit_Arel_Nodes_Bin o
+        visit o.expr
       end
 
-      def visit_Arel_Nodes_Distinct o, a
+      def visit_Arel_Nodes_Distinct o
         DISTINCT
       end
 
-      def visit_Arel_Nodes_DistinctOn o, a
+      def visit_Arel_Nodes_DistinctOn o
         raise NotImplementedError, 'DISTINCT ON not implemented for this db'
       end
 
-      def visit_Arel_Nodes_With o, a
-        "WITH #{o.children.map { |x| visit x, a }.join(', ')}"
+      def visit_Arel_Nodes_With o
+        "WITH #{o.children.map { |x| visit x }.join(', ')}"
       end
 
-      def visit_Arel_Nodes_WithRecursive o, a
-        "WITH RECURSIVE #{o.children.map { |x| visit x, a }.join(', ')}"
+      def visit_Arel_Nodes_WithRecursive o
+        "WITH RECURSIVE #{o.children.map { |x| visit x }.join(', ')}"
       end
 
-      def visit_Arel_Nodes_Union o, a
-        "( #{visit o.left, a} UNION #{visit o.right, a} )"
+      def visit_Arel_Nodes_Union o
+        "( #{visit o.left} UNION #{visit o.right} )"
       end
 
-      def visit_Arel_Nodes_UnionAll o, a
-        "( #{visit o.left, a} UNION ALL #{visit o.right, a} )"
+      def visit_Arel_Nodes_UnionAll o
+        "( #{visit o.left} UNION ALL #{visit o.right} )"
       end
 
-      def visit_Arel_Nodes_Intersect o, a
-        "( #{visit o.left, a} INTERSECT #{visit o.right, a} )"
+      def visit_Arel_Nodes_Intersect o
+        "( #{visit o.left} INTERSECT #{visit o.right} )"
       end
 
-      def visit_Arel_Nodes_Except o, a
-        "( #{visit o.left, a} EXCEPT #{visit o.right, a} )"
+      def visit_Arel_Nodes_Except o
+        "( #{visit o.left} EXCEPT #{visit o.right} )"
       end
 
-      def visit_Arel_Nodes_NamedWindow o, a
-        "#{quote_column_name o.name} AS #{visit_Arel_Nodes_Window o, a}"
+      def visit_Arel_Nodes_NamedWindow o
+        "#{quote_column_name o.name} AS #{visit_Arel_Nodes_Window o}"
       end
 
-      def visit_Arel_Nodes_Window o, a
+      def visit_Arel_Nodes_Window o
         s = [
-          ("ORDER BY #{o.orders.map { |x| visit(x, a) }.join(', ')}" unless o.orders.empty?),
-          (visit o.framing, a if o.framing)
+          ("ORDER BY #{o.orders.map { |x| visit(x) }.join(', ')}" unless o.orders.empty?),
+          (visit o.framing if o.framing)
         ].compact.join ' '
         "(#{s})"
       end
 
-      def visit_Arel_Nodes_Rows o, a
+      def visit_Arel_Nodes_Rows o
         if o.expr
-          "ROWS #{visit o.expr, a}"
+          "ROWS #{visit o.expr}"
         else
           "ROWS"
         end
       end
 
-      def visit_Arel_Nodes_Range o, a
+      def visit_Arel_Nodes_Range o
         if o.expr
-          "RANGE #{visit o.expr, a}"
+          "RANGE #{visit o.expr}"
         else
           "RANGE"
         end
       end
 
-      def visit_Arel_Nodes_Preceding o, a
-        "#{o.expr ? visit(o.expr, a) : 'UNBOUNDED'} PRECEDING"
+      def visit_Arel_Nodes_Preceding o
+        "#{o.expr ? visit(o.expr) : 'UNBOUNDED'} PRECEDING"
       end
 
-      def visit_Arel_Nodes_Following o, a
-        "#{o.expr ? visit(o.expr, a) : 'UNBOUNDED'} FOLLOWING"
+      def visit_Arel_Nodes_Following o
+        "#{o.expr ? visit(o.expr) : 'UNBOUNDED'} FOLLOWING"
       end
 
-      def visit_Arel_Nodes_CurrentRow o, a
+      def visit_Arel_Nodes_CurrentRow o
         "CURRENT ROW"
       end
 
-      def visit_Arel_Nodes_Over o, a
+      def visit_Arel_Nodes_Over o
         case o.right
           when nil
-            "#{visit o.left, a} OVER ()"
+            "#{visit o.left} OVER ()"
           when Arel::Nodes::SqlLiteral
-            "#{visit o.left, a} OVER #{visit o.right, a}"
+            "#{visit o.left} OVER #{visit o.right}"
           when String, Symbol
-            "#{visit o.left, a} OVER #{quote_column_name o.right.to_s}"
+            "#{visit o.left} OVER #{quote_column_name o.right.to_s}"
           else
-            "#{visit o.left, a} OVER #{visit o.right, a}"
+            "#{visit o.left} OVER #{visit o.right}"
         end
       end
 
-      def visit_Arel_Nodes_Having o, a
-        "HAVING #{visit o.expr, a}"
+      def visit_Arel_Nodes_Having o
+        "HAVING #{visit o.expr}"
       end
 
-      def visit_Arel_Nodes_Offset o, a
-        "OFFSET #{visit o.expr, a}"
+      def visit_Arel_Nodes_Offset o
+        "OFFSET #{visit o.expr}"
       end
 
-      def visit_Arel_Nodes_Limit o, a
-        "LIMIT #{visit o.expr, a}"
+      def visit_Arel_Nodes_Limit o
+        "LIMIT #{visit o.expr}"
       end
 
       # FIXME: this does nothing on most databases, but does on MSSQL
-      def visit_Arel_Nodes_Top o, a
+      def visit_Arel_Nodes_Top o
         ""
       end
 
-      def visit_Arel_Nodes_Lock o, a
-        visit o.expr, a
+      def visit_Arel_Nodes_Lock o
+        visit o.expr
       end
 
-      def visit_Arel_Nodes_Grouping o, a
-        "(#{visit o.expr, a})"
+      def visit_Arel_Nodes_Grouping o
+        "(#{visit o.expr})"
       end
 
-      def visit_Arel_SelectManager o, a
+      def visit_Arel_SelectManager o
         "(#{o.to_sql.rstrip})"
       end
 
-      def visit_Arel_Nodes_Ascending o, a
-        "#{visit o.expr, a} ASC"
+      def visit_Arel_Nodes_Ascending o
+        "#{visit o.expr} ASC"
       end
 
-      def visit_Arel_Nodes_Descending o, a
-        "#{visit o.expr, a} DESC"
+      def visit_Arel_Nodes_Descending o
+        "#{visit o.expr} DESC"
       end
 
-      def visit_Arel_Nodes_Group o, a
-        visit o.expr, a
+      def visit_Arel_Nodes_Group o
+        visit o.expr
       end
 
-      def visit_Arel_Nodes_NamedFunction o, a
+      def visit_Arel_Nodes_NamedFunction o
         "#{o.name}(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a
-        }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+          visit x
+        }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
-      def visit_Arel_Nodes_Extract o, a
-        "EXTRACT(#{o.field.to_s.upcase} FROM #{visit o.expr, a})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_Extract o
+        "EXTRACT(#{o.field.to_s.upcase} FROM #{visit o.expr})#{o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
-      def visit_Arel_Nodes_Count o, a
+      def visit_Arel_Nodes_Count o
         "COUNT(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a
-        }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+          visit x
+        }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
-      def visit_Arel_Nodes_Sum o, a
+      def visit_Arel_Nodes_Sum o
         "SUM(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+          visit x}.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
-      def visit_Arel_Nodes_Max o, a
+      def visit_Arel_Nodes_Max o
         "MAX(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+          visit x}.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
-      def visit_Arel_Nodes_Min o, a
+      def visit_Arel_Nodes_Min o
         "MIN(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
-      def visit_Arel_Nodes_Avg o, a
+      def visit_Arel_Nodes_Avg o
         "AVG(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
-      def visit_Arel_Nodes_TableAlias o, a
-        "#{visit o.relation, a} #{quote_table_name o.name}"
+      def visit_Arel_Nodes_TableAlias o
+        "#{visit o.relation} #{quote_table_name o.name}"
       end
 
-      def visit_Arel_Nodes_Between o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} BETWEEN #{visit o.right, a}"
+      def visit_Arel_Nodes_Between o
+        "#{visit o.left} BETWEEN #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_GreaterThanOrEqual o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} >= #{visit o.right, a}"
+      def visit_Arel_Nodes_GreaterThanOrEqual o
+        "#{visit o.left} >= #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_GreaterThan o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} > #{visit o.right, a}"
+      def visit_Arel_Nodes_GreaterThan o
+        "#{visit o.left} > #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_LessThanOrEqual o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} <= #{visit o.right, a}"
+      def visit_Arel_Nodes_LessThanOrEqual o
+        "#{visit o.left} <= #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_LessThan o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} < #{visit o.right, a}"
+      def visit_Arel_Nodes_LessThan o
+        "#{visit o.left} < #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_Matches o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} LIKE #{visit o.right, a}"
+      def visit_Arel_Nodes_Matches o
+        "#{visit o.left} LIKE #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_DoesNotMatch o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} NOT LIKE #{visit o.right, a}"
+      def visit_Arel_Nodes_DoesNotMatch o
+        "#{visit o.left} NOT LIKE #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_JoinSource o, a
+      def visit_Arel_Nodes_JoinSource o
         [
-          (visit(o.left, a) if o.left),
-          o.right.map { |j| visit j, a }.join(' ')
+          (visit(o.left) if o.left),
+          o.right.map { |j| visit j }.join(' ')
         ].compact.join ' '
       end
 
-      def visit_Arel_Nodes_StringJoin o, a
-        visit o.left, a
+      def visit_Arel_Nodes_StringJoin o
+        visit o.left
       end
 
-      def visit_Arel_Nodes_OuterJoin o, a
-        "LEFT OUTER JOIN #{visit o.left, a} #{visit o.right, a}"
+      def visit_Arel_Nodes_OuterJoin o
+        "LEFT OUTER JOIN #{visit o.left} #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_InnerJoin o, a
-        s = "INNER JOIN #{visit o.left, a}"
+      def visit_Arel_Nodes_InnerJoin o
+        s = "INNER JOIN #{visit o.left}"
         if o.right
           s << SPACE
-          s << visit(o.right, a)
+          s << visit(o.right)
         end
         s
       end
 
-      def visit_Arel_Nodes_On o, a
-        "ON #{visit o.expr, a}"
+      def visit_Arel_Nodes_On o
+        "ON #{visit o.expr}"
       end
 
-      def visit_Arel_Nodes_Not o, a
-        "NOT (#{visit o.expr, a})"
+      def visit_Arel_Nodes_Not o
+        "NOT (#{visit o.expr})"
       end
 
-      def visit_Arel_Table o, a
+      def visit_Arel_Table o
         if o.table_alias
           "#{quote_table_name o.name} #{quote_table_name o.table_alias}"
         else
@@ -482,73 +475,69 @@ module Arel
         end
       end
 
-      def visit_Arel_Nodes_In o, a
+      def visit_Arel_Nodes_In o
         if Array === o.right && o.right.empty?
           '1=0'
         else
-          a = o.left if Arel::Attributes::Attribute === o.left
-          "#{visit o.left, a} IN (#{visit o.right, a})"
+          "#{visit o.left} IN (#{visit o.right})"
         end
       end
 
-      def visit_Arel_Nodes_NotIn o, a
+      def visit_Arel_Nodes_NotIn o
         if Array === o.right && o.right.empty?
           '1=1'
         else
-          a = o.left if Arel::Attributes::Attribute === o.left
-          "#{visit o.left, a} NOT IN (#{visit o.right, a})"
+          "#{visit o.left} NOT IN (#{visit o.right})"
         end
       end
 
-      def visit_Arel_Nodes_And o, a
-        o.children.map { |x| visit x, a }.join ' AND '
+      def visit_Arel_Nodes_And o
+        o.children.map { |x| visit x}.join ' AND '
       end
 
-      def visit_Arel_Nodes_Or o, a
-        "#{visit o.left, a} OR #{visit o.right, a}"
+      def visit_Arel_Nodes_Or o
+        "#{visit o.left} OR #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_Assignment o, a
+      def visit_Arel_Nodes_Assignment o
         case o.right
         when Arel::Nodes::UnqualifiedColumn, Arel::Attributes::Attribute
-          "#{visit o.left, a} = #{visit o.right, a}"
+          "#{visit o.left} = #{visit o.right}"
         else
           right = quote(o.right, column_for(o.left))
-          "#{visit o.left, a} = #{right}"
+          "#{visit o.left} = #{right}"
         end
       end
 
-      def visit_Arel_Nodes_Equality o, a
+      def visit_Arel_Nodes_Equality o
         right = o.right
 
-        a = o.left if Arel::Attributes::Attribute === o.left
         if right.nil?
-          "#{visit o.left, a} IS NULL"
+          "#{visit o.left} IS NULL"
         else
-          "#{visit o.left, a} = #{visit right, a}"
+          "#{visit o.left} = #{visit right}"
         end
       end
 
-      def visit_Arel_Nodes_NotEqual o, a
+      def visit_Arel_Nodes_NotEqual o
         right = o.right
 
-        a = o.left if Arel::Attributes::Attribute === o.left
         if right.nil?
-          "#{visit o.left, a} IS NOT NULL"
+          "#{visit o.left} IS NOT NULL"
         else
-          "#{visit o.left, a} != #{visit right, a}"
+          "#{visit o.left} != #{visit right}"
         end
       end
 
-      def visit_Arel_Nodes_As o, a
-        "#{visit o.left, a} AS #{visit o.right, a}"
+      def visit_Arel_Nodes_As o
+        "#{visit o.left} AS #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_UnqualifiedColumn o, a
+      def visit_Arel_Nodes_UnqualifiedColumn o
         "#{quote_column_name o.name}"
       end
 
-      def visit_Arel_Attributes_Attribute o, a
+      def visit_Arel_Attributes_Attribute o
         join_name = o.relation.table_alias || o.relation.name
         "#{quote_table_name join_name}.#{quote_column_name o.name}"
       end
@@ -559,7 +548,7 @@ module Arel
       alias :visit_Arel_Attributes_Time :visit_Arel_Attributes_Attribute
       alias :visit_Arel_Attributes_Boolean :visit_Arel_Attributes_Attribute
 
-      def literal o, a; o end
+      def literal o; o end
 
       alias :visit_Arel_Nodes_BindParam  :literal
       alias :visit_Arel_Nodes_SqlLiteral :literal
@@ -589,8 +578,8 @@ module Arel
       alias :visit_Time                          :unsupported
       alias :visit_TrueClass                     :unsupported
 
-      def visit_Arel_Nodes_InfixOperation o, a
-        "#{visit o.left, a} #{o.operator} #{visit o.right, a}"
+      def visit_Arel_Nodes_InfixOperation o
+        "#{visit o.left} #{o.operator} #{visit o.right}"
       end
 
       alias :visit_Arel_Nodes_Addition       :visit_Arel_Nodes_InfixOperation
@@ -598,8 +587,8 @@ module Arel
       alias :visit_Arel_Nodes_Multiplication :visit_Arel_Nodes_InfixOperation
       alias :visit_Arel_Nodes_Division       :visit_Arel_Nodes_InfixOperation
 
-      def visit_Array o, a
-        o.map { |x| visit x, a }.join(', ')
+      def visit_Array o
+        o.map { |x| visit x }.join(', ')
       end
 
       def quote value, column = nil
diff --git a/lib/arel/visitors/visitor.rb b/lib/arel/visitors/visitor.rb
index 420549b2aa..437dc68e92 100644
--- a/lib/arel/visitors/visitor.rb
+++ b/lib/arel/visitors/visitor.rb
@@ -19,7 +19,7 @@ module Arel
       end
 
       def visit object, attribute = nil
-        send dispatch[object.class], object, attribute
+        send dispatch[object.class], object 
       rescue NoMethodError => e
         raise e if respond_to?(dispatch[object.class], true)
         superklass = object.class.ancestors.find { |klass|
diff --git a/lib/arel/visitors/where_sql.rb b/lib/arel/visitors/where_sql.rb
index d59bc26cb4..acd84cd631 100644
--- a/lib/arel/visitors/where_sql.rb
+++ b/lib/arel/visitors/where_sql.rb
@@ -1,8 +1,8 @@
 module Arel
   module Visitors
     class WhereSql < Arel::Visitors::ToSql
-      def visit_Arel_Nodes_SelectCore o, a
-        "WHERE #{o.wheres.map { |x| visit x, a }.join ' AND ' }"
+      def visit_Arel_Nodes_SelectCore o
+        "WHERE #{o.wheres.map { |x| visit x}.join ' AND ' }"
       end
     end
   end
-- 
cgit v1.2.3