pull parent and alias tacker from the nodes.

For now, we'll set the tables on the nodes manually.

activerecord/lib/active_record/associations/join_dependency.rb

@@ -117,6 +117,21 @@ def make_joins(node)
         }
       end
 
+      def construct_tables!(parent, node)
+        node.tables = node.reflection.chain.map { |reflection|
+          alias_tracker.aliased_table_for(
+            reflection.table_name,
+            table_alias_for(reflection, parent, reflection != node.reflection)
+          )
+        }.reverse
+      end
+
+      def table_alias_for(reflection, parent, join)
+        name = "#{reflection.plural_name}_#{parent.table_name}"
+        name << "_join" if join
+        name
+      end
+
       def merge_node(left, right)
         intersection, missing = right.children.map { |node1|
           [left.children.find { |node2| node1.match? node2 }, node1]
@@ -187,7 +202,9 @@ def build_join_association(reflection, parent, join_type)
           raise EagerLoadPolymorphicError.new(reflection)
         end
 
-        JoinAssociation.new(reflection, join_root.to_a.length, parent, join_type, alias_tracker)
+        node = JoinAssociation.new(reflection, join_root.to_a.length, join_type)
+        construct_tables!(parent, node)
+        node
       end
 
       def construct(ar_parent, parent, row, rs)

activerecord/lib/active_record/associations/join_dependency/join_association.rb

@@ -15,24 +15,19 @@ class JoinAssociation < JoinPart # :nodoc:
         # These implement abstract methods from the superclass
         attr_reader :aliased_prefix
 
-        attr_reader :tables
-        attr_reader :alias_tracker
+        attr_accessor :tables
 
         delegate :options, :through_reflection, :source_reflection, :chain, :to => :reflection
 
-        def initialize(reflection, index, parent, join_type, alias_tracker)
-          super(reflection.klass, parent)
+        def initialize(reflection, index, join_type)
+          super(reflection.klass)
 
           @reflection      = reflection
-          @alias_tracker   = alias_tracker
           @join_type       = join_type
           @aliased_prefix  = "t#{ index }"
-          @tables          = construct_tables.reverse
+          @tables          = nil
         end
 
-        def parent_table_name; parent.table_name; end
-        alias :alias_suffix :parent_table_name
-
         def match?(other)
           return true if self == other
           super && reflection == other.reflection

activerecord/lib/active_record/associations/join_dependency/join_base.rb

@@ -4,10 +4,6 @@ module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinBase < JoinPart # :nodoc:
-        def initialize(klass)
-          super(klass, nil)
-        end
-
         def match?(other)
           return true if self == other
           super && base_klass == other.base_klass

activerecord/lib/active_record/associations/join_dependency/join_part.rb

@@ -10,20 +10,15 @@ class JoinDependency # :nodoc:
       class JoinPart # :nodoc:
         include Enumerable
 
-        # A JoinBase instance representing the active record we are joining onto.
-        # (So in Author.has_many :posts, the Author would be that base record.)
-        attr_reader :parent
-
         # The Active Record class which this join part is associated 'about'; for a JoinBase
         # this is the actual base model, for a JoinAssociation this is the target model of the
         # association.
         attr_reader :base_klass, :children
 
         delegate :table_name, :column_names, :primary_key, :arel_engine, :to => :base_klass
 
-        def initialize(base_klass, parent)
+        def initialize(base_klass)
           @base_klass = base_klass
-          @parent = parent
           @cached_record = {}
           @column_names_with_alias = nil
           @children = []