1 files changed, 27 insertions, 40 deletions

diff --git a/activerecord/lib/active_record/associations/association_scope.rb b/activerecord/lib/active_record/associations/association_scope.rb
index 3d79e540b8..11967e0571 100644
--- a/activerecord/lib/active_record/associations/association_scope.rb
+++ b/activerecord/lib/active_record/associations/association_scope.rb
@@ -23,15 +23,10 @@ module ActiveRecord
         reflection = association.reflection
         scope = klass.unscoped
         owner = association.owner
-        alias_tracker = AliasTracker.create(klass.connection, klass.table_name)
-        chain_head, chain_tail = get_chain(reflection, association, alias_tracker)
+        chain = get_chain(reflection, association, scope.alias_tracker)
 
         scope.extending! reflection.extensions
-        add_constraints(scope, owner, reflection, chain_head, chain_tail)
-      end
-
-      def join_type
-        Arel::Nodes::InnerJoin
+        add_constraints(scope, owner, chain)
       end
 
       def self.get_bind_values(owner, chain)
@@ -59,14 +54,15 @@ module ActiveRecord
 
       private
         def join(table, constraint)
-          table.create_join(table, table.create_on(constraint), join_type)
+          table.create_join(table, table.create_on(constraint))
         end
 
-        def last_chain_scope(scope, table, reflection, owner)
+        def last_chain_scope(scope, reflection, owner)
           join_keys = reflection.join_keys
           key = join_keys.key
           foreign_key = join_keys.foreign_key
 
+          table = reflection.aliased_table
           value = transform_value(owner[foreign_key])
           scope = apply_scope(scope, table, key, value)
 
@@ -82,11 +78,13 @@ module ActiveRecord
           value_transformation.call(value)
         end
 
-        def next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
+        def next_chain_scope(scope, reflection, next_reflection)
           join_keys = reflection.join_keys
           key = join_keys.key
           foreign_key = join_keys.foreign_key
 
+          table = reflection.aliased_table
+          foreign_table = next_reflection.aliased_table
           constraint = table[key].eq(foreign_table[foreign_key])
 
           if reflection.type
@@ -98,12 +96,11 @@ module ActiveRecord
         end
 
         class ReflectionProxy < SimpleDelegator # :nodoc:
-          attr_accessor :next
-          attr_reader :alias_name
+          attr_reader :aliased_table
 
-          def initialize(reflection, alias_name)
+          def initialize(reflection, aliased_table)
             super(reflection)
-            @alias_name = alias_name
+            @aliased_table = aliased_table
           end
 
           def all_includes; nil; end
@@ -111,42 +108,33 @@ module ActiveRecord
 
         def get_chain(reflection, association, tracker)
           name = reflection.name
-          runtime_reflection = Reflection::RuntimeReflection.new(reflection, association)
-          previous_reflection = runtime_reflection
+          chain = [Reflection::RuntimeReflection.new(reflection, association)]
           reflection.chain.drop(1).each do |refl|
-            alias_name = tracker.aliased_table_for(
+            aliased_table = tracker.aliased_table_for(
               refl.table_name,
               refl.alias_candidate(name),
               refl.klass.type_caster
             )
-            proxy = ReflectionProxy.new(refl, alias_name)
-            previous_reflection.next = proxy
-            previous_reflection = proxy
+            chain << ReflectionProxy.new(refl, aliased_table)
           end
-          [runtime_reflection, previous_reflection]
+          chain
         end
 
-        def add_constraints(scope, owner, refl, chain_head, chain_tail)
-          owner_reflection = chain_tail
-          table = owner_reflection.alias_name
-          scope = last_chain_scope(scope, table, owner_reflection, owner)
-
-          reflection = chain_head
-          while reflection
-            table = reflection.alias_name
-            next_reflection = reflection.next
+        def add_constraints(scope, owner, chain)
+          scope = last_chain_scope(scope, chain.last, owner)
 
-            unless reflection == chain_tail
-              foreign_table = next_reflection.alias_name
-              scope = next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
-            end
+          chain.each_cons(2) do |reflection, next_reflection|
+            scope = next_chain_scope(scope, reflection, next_reflection)
+          end
 
+          chain_head = chain.first
+          chain.reverse_each do |reflection|
             # Exclude the scope of the association itself, because that
             # was already merged in the #scope method.
             reflection.constraints.each do |scope_chain_item|
-              item = eval_scope(reflection, table, scope_chain_item, owner)
+              item = eval_scope(reflection, scope_chain_item, owner)
 
-              if scope_chain_item == refl.scope
+              if scope_chain_item == chain_head.scope
                 scope.merge! item.except(:where, :includes)
               end
 
@@ -158,8 +146,6 @@ module ActiveRecord
               scope.where_clause += item.where_clause
               scope.order_values |= item.order_values
             end
-
-            reflection = next_reflection
           end
 
           scope
@@ -173,8 +159,9 @@ module ActiveRecord
           end
         end
 
-        def eval_scope(reflection, table, scope, owner)
-          reflection.build_scope(table).instance_exec(owner, &scope)
+        def eval_scope(reflection, scope, owner)
+          relation = reflection.build_scope(reflection.aliased_table)
+          relation.instance_exec(owner, &scope) || relation
         end
     end
   end