Make naming of Exchange, X, ExchangeName, XName consistent

3 files changed, 66 insertions, 67 deletions

diff --git a/src/rabbit_binding.erl b/src/rabbit_binding.erl
index bb29580fd4..19150fa9f9 100644
--- a/src/rabbit_binding.erl
+++ b/src/rabbit_binding.erl
@@ -129,8 +129,8 @@ add(Binding, InnerFun) ->
                            E
                    end
            end) of
-        {new, Exchange = #exchange{ type = Type }, B} ->
-            ok = (type_to_module(Type)):add_binding(Exchange, B),
+        {new, X = #exchange{ type = Type }, B} ->
+            ok = (type_to_module(Type)):add_binding(X, B),
             rabbit_event:notify(binding_created, info(B));
         {existing, _, _} ->
             ok;
@@ -181,8 +181,8 @@ list(VHostPath) ->
     [B || #route{binding = B} <- mnesia:dirty_match_object(rabbit_route,
                                                            Route)].
 
-list_for_exchange(ExchangeName) ->
-    Route = #route{binding = #binding{exchange_name = ExchangeName, _ = '_'}},
+list_for_exchange(XName) ->
+    Route = #route{binding = #binding{exchange_name = XName, _ = '_'}},
     [B || #route{binding = B} <- mnesia:dirty_match_object(rabbit_route,
                                                            Route)].
 
@@ -192,8 +192,8 @@ list_for_queue(QueueName) ->
                                mnesia:dirty_match_object(rabbit_reverse_route,
                                                          reverse_route(Route))].
 
-list_for_exchange_and_queue(ExchangeName, QueueName) ->
-    Route = #route{binding = #binding{exchange_name = ExchangeName,
+list_for_exchange_and_queue(XName, QueueName) ->
+    Route = #route{binding = #binding{exchange_name = XName,
                                       queue_name    = QueueName,
                                       _             = '_'}},
     [B || #route{binding = B} <- mnesia:dirty_match_object(rabbit_route,
@@ -222,14 +222,14 @@ info_all(VHostPath) -> map(VHostPath, fun (B) -> info(B) end).
 
 info_all(VHostPath, Items) -> map(VHostPath, fun (B) -> info(B, Items) end).
 
-has_for_exchange(ExchangeName) ->
-    Match = #route{binding = #binding{exchange_name = ExchangeName, _ = '_'}},
+has_for_exchange(XName) ->
+    Match = #route{binding = #binding{exchange_name = XName, _ = '_'}},
     %% we need to check for durable routes here too in case a bunch of
     %% routes to durable queues have been removed temporarily as a
     %% result of a node failure
     contains(rabbit_route, Match) orelse contains(rabbit_durable_route, Match).
 
-remove_for_exchange(ExchangeName) ->
+remove_for_exchange(XName) ->
     [begin
          ok = mnesia:delete_object(rabbit_reverse_route,
                                    reverse_route(Route), write),
@@ -237,7 +237,7 @@ remove_for_exchange(ExchangeName) ->
          Route#route.binding
      end || Route <- mnesia:match_object(
                        rabbit_route,
-                       #route{binding = #binding{exchange_name = ExchangeName,
+                       #route{binding = #binding{exchange_name = XName,
                                                  _ = '_'}},
                        write)].
 
@@ -249,11 +249,11 @@ remove_transient_for_queue(QueueName) ->
 
 %%----------------------------------------------------------------------------
 
-binding_action(Binding = #binding{exchange_name = ExchangeName,
+binding_action(Binding = #binding{exchange_name = XName,
                                   queue_name    = QueueName,
                                   args          = Arguments}, Fun) ->
     call_with_exchange_and_queue(
-      ExchangeName, QueueName,
+      XName, QueueName,
       fun (X, Q) ->
               SortedArgs = rabbit_misc:sort_field_table(Arguments),
               Fun(X, Q, Binding#binding{args = SortedArgs})
@@ -270,10 +270,10 @@ sync_binding(Binding, Durable, Fun) ->
     ok = Fun(rabbit_reverse_route, ReverseRoute, write),
     ok.
 
-call_with_exchange_and_queue(Exchange, Queue, Fun) ->
+call_with_exchange_and_queue(XName, QueueName, Fun) ->
     rabbit_misc:execute_mnesia_transaction(
-      fun () -> case {mnesia:read({rabbit_exchange, Exchange}),
-                      mnesia:read({rabbit_queue, Queue})} of
+      fun () -> case {mnesia:read({rabbit_exchange, XName}),
+                      mnesia:read({rabbit_queue, QueueName})} of
                    {[X], [Q]} -> Fun(X, Q);
                    {[ ], [_]} -> {error, exchange_not_found};
                    {[_], [ ]} -> {error, queue_not_found};
@@ -327,16 +327,15 @@ remove_for_queue(QueueName, FwdDeleteFun) ->
 group_bindings_and_auto_delete([], Acc) ->
     Acc;
 group_bindings_and_auto_delete(
-  [B = #binding{exchange_name = ExchangeName} | Bs], Acc) ->
-    group_bindings_and_auto_delete(ExchangeName, Bs, [B], Acc).
+  [B = #binding{exchange_name = XName} | Bs], Acc) ->
+    group_bindings_and_auto_delete(XName, Bs, [B], Acc).
 
 group_bindings_and_auto_delete(
-  ExchangeName, [B = #binding{exchange_name = ExchangeName} | Bs],
-  Bindings, Acc) ->
-    group_bindings_and_auto_delete(ExchangeName, Bs, [B | Bindings], Acc);
-group_bindings_and_auto_delete(ExchangeName, Removed, Bindings, Acc) ->
-    %% either Removed is [], or its head has a non-matching ExchangeName
-    [X] = mnesia:read({rabbit_exchange, ExchangeName}),
+  XName, [B = #binding{exchange_name = XName} | Bs], Bindings, Acc) ->
+    group_bindings_and_auto_delete(XName, Bs, [B | Bindings], Acc);
+group_bindings_and_auto_delete(XName, Removed, Bindings, Acc) ->
+    %% either Removed is [], or its head has a non-matching XName
+    [X] = mnesia:read({rabbit_exchange, XName}),
     NewAcc = [{{rabbit_exchange:maybe_auto_delete(X), X}, Bindings} | Acc],
     group_bindings_and_auto_delete(Removed, NewAcc).
 
@@ -359,20 +358,20 @@ reverse_route(#route{binding = Binding}) ->
 reverse_route(#reverse_route{reverse_binding = Binding}) ->
     #route{binding = reverse_binding(Binding)}.
 
-reverse_binding(#reverse_binding{exchange_name = Exchange,
-                                 queue_name    = Queue,
+reverse_binding(#reverse_binding{exchange_name = XName,
+                                 queue_name    = QueueName,
                                  key           = Key,
                                  args          = Args}) ->
-    #binding{exchange_name = Exchange,
-             queue_name    = Queue,
+    #binding{exchange_name = XName,
+             queue_name    = QueueName,
              key           = Key,
              args          = Args};
 
-reverse_binding(#binding{exchange_name = Exchange,
-                         queue_name    = Queue,
+reverse_binding(#binding{exchange_name = XName,
+                         queue_name    = QueueName,
                          key           = Key,
                          args          = Args}) ->
-    #reverse_binding{exchange_name = Exchange,
-                     queue_name    = Queue,
+    #reverse_binding{exchange_name = XName,
+                     queue_name    = QueueName,
                      key           = Key,
                      args          = Args}.
diff --git a/src/rabbit_exchange.erl b/src/rabbit_exchange.erl
index 40bee25f8b..2a19d5b1c8 100644
--- a/src/rabbit_exchange.erl
+++ b/src/rabbit_exchange.erl
@@ -92,15 +92,15 @@
 -define(INFO_KEYS, [name, type, durable, auto_delete, arguments]).
 
 recover() ->
-    Exs = rabbit_misc:table_fold(
-            fun (Exchange, Acc) ->
-                    ok = mnesia:write(rabbit_exchange, Exchange, write),
-                    [Exchange | Acc]
-            end, [], rabbit_durable_exchange),
+    Xs = rabbit_misc:table_fold(
+           fun (X, Acc) ->
+                   ok = mnesia:write(rabbit_exchange, X, write),
+                   [X | Acc]
+           end, [], rabbit_durable_exchange),
     Bs = rabbit_binding:recover(),
     recover_with_bindings(
       lists:keysort(#binding.exchange_name, Bs),
-      lists:keysort(#exchange.name, Exs), []).
+      lists:keysort(#exchange.name, Xs), []).
 
 recover_with_bindings([B = #binding{exchange_name = Name} | Rest],
                       Xs = [#exchange{name = Name} | _],
@@ -112,30 +112,30 @@ recover_with_bindings(Bs, [X = #exchange{type = Type} | Xs], Bindings) ->
 recover_with_bindings([], [], []) ->
     ok.
 
-declare(ExchangeName, Type, Durable, AutoDelete, Args) ->
-    Exchange = #exchange{name        = ExchangeName,
-                         type        = Type,
-                         durable     = Durable,
-                         auto_delete = AutoDelete,
-                         arguments   = Args},
+declare(XName, Type, Durable, AutoDelete, Args) ->
+    X = #exchange{name        = XName,
+                  type        = Type,
+                  durable     = Durable,
+                  auto_delete = AutoDelete,
+                  arguments   = Args},
     %% We want to upset things if it isn't ok; this is different from
     %% the other hooks invocations, where we tend to ignore the return
     %% value.
     TypeModule = type_to_module(Type),
-    ok = TypeModule:validate(Exchange),
+    ok = TypeModule:validate(X),
     case rabbit_misc:execute_mnesia_transaction(
            fun () ->
-                   case mnesia:wread({rabbit_exchange, ExchangeName}) of
+                   case mnesia:wread({rabbit_exchange, XName}) of
                        [] ->
-                           ok = mnesia:write(rabbit_exchange, Exchange, write),
+                           ok = mnesia:write(rabbit_exchange, X, write),
                            ok = case Durable of
                                     true ->
                                         mnesia:write(rabbit_durable_exchange,
-                                                     Exchange, write);
+                                                     X, write);
                                     false ->
                                         ok
                            end,
-                           {new, Exchange};
+                           {new, X};
                        [ExistingX] ->
                            {existing, ExistingX}
                    end
@@ -257,20 +257,20 @@ publish(X = #exchange{type = Type}, Seen, Delivery) ->
             R
     end.
 
-call_with_exchange(Exchange, Fun) ->
+call_with_exchange(XName, Fun) ->
     rabbit_misc:execute_mnesia_transaction(
-      fun () -> case mnesia:read({rabbit_exchange, Exchange}) of
+      fun () -> case mnesia:read({rabbit_exchange, XName}) of
                    []  -> {error, not_found};
                    [X] -> Fun(X)
                end
       end).
 
-delete(ExchangeName, IfUnused) ->
+delete(XName, IfUnused) ->
     Fun = case IfUnused of
               true  -> fun conditional_delete/1;
               false -> fun unconditional_delete/1
           end,
-    case call_with_exchange(ExchangeName, Fun) of
+    case call_with_exchange(XName, Fun) of
         {deleted, X = #exchange{type = Type}, Bs} ->
             (type_to_module(Type)):delete(X, Bs),
             ok;
@@ -280,21 +280,21 @@ delete(ExchangeName, IfUnused) ->
 
 maybe_auto_delete(#exchange{auto_delete = false}) ->
     not_deleted;
-maybe_auto_delete(#exchange{auto_delete = true} = Exchange) ->
-    case conditional_delete(Exchange) of
-        {error, in_use}         -> not_deleted;
-        {deleted, Exchange, []} -> auto_deleted
+maybe_auto_delete(#exchange{auto_delete = true} = X) ->
+    case conditional_delete(X) of
+        {error, in_use}  -> not_deleted;
+        {deleted, X, []} -> auto_deleted
     end.
 
-conditional_delete(Exchange = #exchange{name = ExchangeName}) ->
-    case rabbit_binding:has_for_exchange(ExchangeName) of
-        false  -> unconditional_delete(Exchange);
+conditional_delete(X = #exchange{name = XName}) ->
+    case rabbit_binding:has_for_exchange(XName) of
+        false  -> unconditional_delete(X);
         true   -> {error, in_use}
     end.
 
-unconditional_delete(Exchange = #exchange{name = ExchangeName}) ->
-    Bindings = rabbit_binding:remove_for_exchange(ExchangeName),
-    ok = mnesia:delete({rabbit_durable_exchange, ExchangeName}),
-    ok = mnesia:delete({rabbit_exchange, ExchangeName}),
-    rabbit_event:notify(exchange_deleted, [{name, ExchangeName}]),
-    {deleted, Exchange, Bindings}.
+unconditional_delete(X = #exchange{name = XName}) ->
+    Bindings = rabbit_binding:remove_for_exchange(XName),
+    ok = mnesia:delete({rabbit_durable_exchange, XName}),
+    ok = mnesia:delete({rabbit_exchange, XName}),
+    rabbit_event:notify(exchange_deleted, [{name, XName}]),
+    {deleted, X, Bindings}.
diff --git a/src/rabbit_router.erl b/src/rabbit_router.erl
index bfccb0daa5..bd57f73726 100644
--- a/src/rabbit_router.erl
+++ b/src/rabbit_router.erl
@@ -85,10 +85,10 @@ deliver(QPids, Delivery) ->
 %% TODO: This causes a full scan for each entry with the same exchange
 match_bindings(Name, Match) ->
     Query = qlc:q([QName || #route{binding = Binding = #binding{
-                                               exchange_name = ExchangeName,
+                                               exchange_name = XName,
                                                queue_name = QName}} <-
                                 mnesia:table(rabbit_route),
-                            ExchangeName == Name,
+                            XName == Name,
                             Match(Binding)]),
     lookup_qpids(mnesia:async_dirty(fun qlc:e/1, [Query])).