dartfmt pkg/compiler

pkg/compiler/lib/src/tree_ir/optimization/variable_merger.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library tree_ir.optimization.variable_merger;
 
 import 'optimization.dart' show Pass;
 import '../tree_ir_nodes.dart';
 
 /// Merges variables based on liveness and source variable information.
 ///
 /// This phase cleans up artifacts introduced by the translation through CPS,
 /// where each source variable is translated into several copies. The copies
 /// are merged again when they are not live simultaneously.
 class VariableMerger implements Pass {
   String get passName => 'Variable merger';
 
   final bool minifying;
 
   VariableMerger({this.minifying: false});
 
   void rewrite(FunctionDefinition node) {
     BlockGraphBuilder builder = new BlockGraphBuilder()..build(node);
     _computeLiveness(builder.blocks);
     PriorityPairs priority = new PriorityPairs()..build(node);
     Map<Variable, Variable> subst = _computeRegisterAllocation(
-        builder.blocks, node.parameters, priority, minifying: minifying);
+        builder.blocks, node.parameters, priority,
+        minifying: minifying);
     new SubstituteVariables(subst).apply(node);
   }
 }
 
 /// A read or write access to a variable.
 class VariableAccess {
   Variable variable;
   bool isRead;
   bool get isWrite => !isRead;
 
@@ skipping 231 matching lines @@
     _priority.putIfAbsent(x, () => new List<Variable>()).add(y);
     _priority.putIfAbsent(y, () => new List<Variable>()).add(x);
   }
 
   visitAssign(Assign node) {
     super.visitAssign(node);
     Expression value = node.value;
     if (value is VariableUse) {
       _prioritize(node.variable, value.variable);
     } else if (value is ApplyBuiltinOperator &&
-               isCompoundableOperator(value.operator) &&
-               value.arguments[0] is VariableUse) {
+        isCompoundableOperator(value.operator) &&
+        value.arguments[0] is VariableUse) {
       VariableUse use = value.arguments[0];
       _prioritize(node.variable, use.variable);
     }
   }
 
   /// Returns the other half of every priority pair containing [variable].
   List<Variable> getPriorityPairsWith(Variable variable) {
     return _priority[variable] ?? const <Variable>[];
   }
 
@@ skipping 87 matching lines @@
 
 /// Based on liveness information, computes a map of variable substitutions to
 /// merge variables.
 ///
 /// Constructs a register interference graph. This is an undirected graph of
 /// variables, with an edge between two variables if they cannot be merged
 /// (because they are live simultaneously).
 ///
 /// We then compute a graph coloring, where the color of a node denotes which
 /// variable it will be substituted by.
-Map<Variable, Variable> _computeRegisterAllocation(List<Block> blocks,
-                                                   List<Variable> parameters,
-                                                   PriorityPairs priority,
-                                                   {bool minifying}) {
+Map<Variable, Variable> _computeRegisterAllocation(
+    List<Block> blocks, List<Variable> parameters, PriorityPairs priority,
+    {bool minifying}) {
   Map<Variable, Set<Variable>> interference = <Variable, Set<Variable>>{};
 
   bool allowUnmotivatedMerge(Variable x, Variable y) {
     if (minifying) return true;
     // Do not allow merging temporaries with named variables if they are
     // not connected by a phi.  That would leads to confusing mergings like:
     //    var v0 = receiver.length;
     //        ==>
     //    receiver = receiver.length;
     return x.element?.name == y.element?.name;
   }
 
   bool allowPhiMerge(Variable x, Variable y) {
     if (minifying) return true;
     // Temporaries may be merged with a named variable if this eliminates a phi.
     // The presence of the phi implies that the two variables can contain the
     // same value, so it is not that confusing that they get the same name.
     return x.element == null ||
-           y.element == null ||
-           x.element.name == y.element.name;
+        y.element == null ||
+        x.element.name == y.element.name;
   }
 
   Set<Variable> empty = new Set<Variable>();
 
   // At the assignment to a variable x, add an edge to every variable that is
   // live after the assignment (if it came from the same source variable).
   for (Block block in blocks) {
     // Track the live set while traversing the block.
     Set<Variable> live = new Set<Variable>();
     for (Variable variable in block.liveOut) {
       live.add(variable);
       interference.putIfAbsent(variable, () => new Set<Variable>());
     }
     // Get variables that are live at the catch block.
-    Set<Variable> liveCatch = block.catchBlock != null
-        ? block.catchBlock.liveIn
-        : empty;
+    Set<Variable> liveCatch =
+        block.catchBlock != null ? block.catchBlock.liveIn : empty;
     // Add edges for each variable being assigned here.
     for (VariableAccess access in block.accesses.reversed) {
       Variable variable = access.variable;
       interference.putIfAbsent(variable, () => new Set<Variable>());
       if (access.isRead) {
         live.add(variable);
       } else {
         if (!liveCatch.contains(variable)) {
           // Assignment to a variable that is not live in the catch block.
           live.remove(variable);
@@ skipping 63 matching lines @@
     if (parameter.isCaptured) continue;
     registers.add(parameter);
     subst[parameter] = parameter;
   }
 
   // Try to merge parameters with locals to eliminate phis.
   for (Variable parameter in parameters) {
     searchPriorityPairs(parameter, parameter);
   }
 
-  v1loop:
-  for (Variable v1 in variables) {
+  v1loop: for (Variable v1 in variables) {
     // Ignore if the variable has already been assigned a register.
     if (subst.containsKey(v1)) continue;
 
     // Optimization: If there are no interference edges for this variable,
     // find a color for it without copying the register list.
     Set<Variable> interferenceSet = interference[v1];
     if (interferenceSet.isEmpty) {
       // Use the first register where naming constraints allow the merge.
       for (Variable v2 in registers) {
         if (allowUnmotivatedMerge(v1, v2)) {
           assignRegister(v1, v2);
           continue v1loop;
         }
       }
       // No register allows merging with this one, create a new register.
       assignNewRegister(v1);
       continue;
     }
 
     // Find an unused color.
     Set<Variable> potential = new Set<Variable>.from(
-          registers.where((v2) => allowUnmotivatedMerge(v1, v2)));
+        registers.where((v2) => allowUnmotivatedMerge(v1, v2)));
     for (Variable v2 in interferenceSet) {
       Variable v2subst = subst[v2];
       if (v2subst != null) {
         potential.remove(v2subst);
         if (potential.isEmpty) break;
       }
     }
 
     if (potential.isEmpty) {
       // If no free color was found, add this variable as a new color.
       assignNewRegister(v1);
     } else {
       assignRegister(v1, potential.first);
     }
   }
 
   return subst;
 }
 
 /// Performs variable substitution and removes redundant assignments.
 class SubstituteVariables extends RecursiveTransformer {
-
   Map<Variable, Variable> mapping;
 
   SubstituteVariables(this.mapping);
 
   Variable replaceRead(Variable variable) {
     Variable w = mapping[variable];
     if (w == null) return variable; // Skip ignored variables.
     w.readCount++;
     variable.readCount--;
     return w;
@@ skipping 39 matching lines @@
     node.expression = visitExpression(node.expression);
     node.next = visitStatement(node.next);
     if (node.expression is VariableUse) {
       VariableUse use = node.expression;
       --use.variable.readCount;
       return node.next;
     }
     return node;
   }
 }