[turbofan] Avoid shadowing of local variables.

src/compiler/js-inlining-heuristic.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/js-inlining-heuristic.h"
 
 #include "src/compilation-info.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/simplified-operator.h"
@@ skipping 179 matching lines @@
     }
     return reduction;
   }
 
   // Expand the JSCallFunction/JSCallConstruct node to a subgraph first if
   // we have multiple known target functions.
   DCHECK_LT(1, num_calls);
   Node* calls[kMaxCallPolymorphism + 1];
   Node* if_successes[kMaxCallPolymorphism];
   Node* callee = NodeProperties::GetValueInput(node, 0);
-  Node* control = NodeProperties::GetControlInput(node);
+  Node* fallthrough_control = NodeProperties::GetControlInput(node);
 
   // Setup the inputs for the cloned call nodes.
   int const input_count = node->InputCount();
   Node** inputs = graph()->zone()->NewArray<Node*>(input_count);
   for (int i = 0; i < input_count; ++i) {
     inputs[i] = node->InputAt(i);
   }
 
   // Create the appropriate control flow to dispatch to the cloned calls.
   for (int i = 0; i < num_calls; ++i) {
     Node* target = jsgraph()->HeapConstant(candidate.functions[i]);
     if (i != (num_calls - 1)) {
       Node* check =
           graph()->NewNode(simplified()->ReferenceEqual(), callee, target);
-      Node* branch = graph()->NewNode(common()->Branch(), check, control);
-      control = graph()->NewNode(common()->IfFalse(), branch);
+      Node* branch =
+          graph()->NewNode(common()->Branch(), check, fallthrough_control);
+      fallthrough_control = graph()->NewNode(common()->IfFalse(), branch);
       if_successes[i] = graph()->NewNode(common()->IfTrue(), branch);
     } else {
-      if_successes[i] = control;
+      if_successes[i] = fallthrough_control;
     }
 
     // The first input to the call is the actual target (which we specialize
     // to the known {target}); the last input is the control dependency.
     inputs[0] = target;
     inputs[input_count - 1] = if_successes[i];
     calls[i] = graph()->NewNode(node->op(), input_count, inputs);
     if_successes[i] = graph()->NewNode(common()->IfSuccess(), calls[i]);
   }
 
   // Check if we have an exception projection for the call {node}.
   Node* if_exception = nullptr;
   for (Edge const edge : node->use_edges()) {
     if (NodeProperties::IsControlEdge(edge) &&
         edge.from()->opcode() == IrOpcode::kIfException) {
       if_exception = edge.from();
       break;
     }
   }
   if (if_exception != nullptr) {
     // Morph the {if_exception} projection into a join.
     Node* if_exceptions[kMaxCallPolymorphism + 1];
     for (int i = 0; i < num_calls; ++i) {
       if_exceptions[i] =
           graph()->NewNode(common()->IfException(), calls[i], calls[i]);
     }
-    Node* control =
+    Node* exception_control =
         graph()->NewNode(common()->Merge(num_calls), num_calls, if_exceptions);
-    if_exceptions[num_calls] = control;
-    Node* effect = graph()->NewNode(common()->EffectPhi(num_calls),
-                                    num_calls + 1, if_exceptions);
-    Node* value = graph()->NewNode(
+    if_exceptions[num_calls] = exception_control;
+    Node* exception_effect = graph()->NewNode(common()->EffectPhi(num_calls),
+                                              num_calls + 1, if_exceptions);
+    Node* exception_value = graph()->NewNode(
         common()->Phi(MachineRepresentation::kTagged, num_calls), num_calls + 1,
         if_exceptions);
-    ReplaceWithValue(if_exception, value, effect, control);
+    ReplaceWithValue(if_exception, exception_value, exception_effect,
+                     exception_control);
   }
 
   // Morph the call site into the dispatched call sites.
-  control =
+  Node* control =
       graph()->NewNode(common()->Merge(num_calls), num_calls, if_successes);
   calls[num_calls] = control;
   Node* effect =
       graph()->NewNode(common()->EffectPhi(num_calls), num_calls + 1, calls);
   Node* value =
       graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, num_calls),
                        num_calls + 1, calls);
   ReplaceWithValue(node, value, effect, control);
 
   // Inline the individual, cloned call sites.
@@ skipping 38 matching lines @@
   return jsgraph()->common();
 }
 
 SimplifiedOperatorBuilder* JSInliningHeuristic::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8