dartfmt pkg/compiler

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

 // Copyright (c) 2014, 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.statement_rewriter;
 
 import 'optimization.dart' show Pass;
 import '../tree_ir_nodes.dart';
 import '../../io/source_information.dart';
 import '../../elements/elements.dart';
@@ skipping 350 matching lines @@
     return visitor.wasFound;
   }
 
   /// Returns true if [exp] has no side effects and has a constant value within
   /// any given activation of the enclosing method.
   bool isEffectivelyConstant(Expression exp) {
     // TODO(asgerf): Can be made more aggressive e.g. by checking conditional
     // expressions recursively. Determine if that is a valuable optimization
     // and/or if it is better handled at the CPS level.
     return exp is Constant ||
-           exp is This ||
-           exp is CreateInvocationMirror ||
-           exp is CreateInstance ||
-           exp is CreateBox ||
-           exp is TypeExpression ||
-           exp is GetStatic && exp.element.isFunction ||
-           exp is Interceptor ||
-           exp is ApplyBuiltinOperator ||
-           exp is VariableUse && constantEnvironment.containsKey(exp.variable);
+        exp is This ||
+        exp is CreateInvocationMirror ||
+        exp is CreateInstance ||
+        exp is CreateBox ||
+        exp is TypeExpression ||
+        exp is GetStatic && exp.element.isFunction ||
+        exp is Interceptor ||
+        exp is ApplyBuiltinOperator ||
+        exp is VariableUse && constantEnvironment.containsKey(exp.variable);
   }
 
   /// True if [node] is an assignment that can be propagated as a constant.
   bool isEffectivelyConstantAssignment(Expression node) {
     return node is Assign &&
-           node.variable.writeCount == 1 &&
-           isEffectivelyConstant(node.value);
+        node.variable.writeCount == 1 &&
+        isEffectivelyConstant(node.value);
   }
 
   Statement visitExpressionStatement(ExpressionStatement inputNode) {
     // Analyze chains of expression statements.
     // To avoid deep recursion, [processExpressionStatement] returns a callback
     // to invoke after its successor node has been processed.
     // These callbacks are stored in a list and invoked in reverse at the end.
     List<Function> stack = [];
     Statement node = inputNode;
     while (node is ExpressionStatement) {
@@ skipping 276 matching lines @@
       node.elseStatement = visitStatement(node.elseStatement);
     });
 
     node.condition = visitExpression(node.condition);
 
     inEmptyEnvironment(() {
       tryCollapseIf(node);
     });
 
     Statement reduced = combineStatementsInBranches(
-        node.thenStatement,
-        node.elseStatement,
-        node.condition);
+        node.thenStatement, node.elseStatement, node.condition);
     if (reduced != null) {
       return reduced;
     }
 
     return node;
   }
 
   Statement visitWhileTrue(WhileTrue node) {
     // Do not propagate assignments into loops.  Doing so is not safe for
     // variables modified in the loop (the initial value will be propagated).
@@ skipping 43 matching lines @@
   }
 
   Expression visitTypeOperator(TypeOperator node) {
     _rewriteList(node.typeArguments);
     node.value = visitExpression(node.value);
     return node;
   }
 
   bool isCompoundableBuiltin(Expression e) {
     return e is ApplyBuiltinOperator &&
-           e.arguments.length >= 2 &&
-           isCompoundableOperator(e.operator);
+        e.arguments.length >= 2 &&
+        isCompoundableOperator(e.operator);
   }
 
   /// Converts a compoundable operator application into the right-hand side for
   /// use in a compound assignment, discarding the left-hand value.
   ///
   /// For example, for `x + y + z` it returns `y + z`.
   Expression contractCompoundableBuiltin(ApplyBuiltinOperator e) {
     assert(isCompoundableBuiltin(e));
     if (e.arguments.length > 2) {
       assert(e.operator == BuiltinOperator.StringConcatenate);
       return new ApplyBuiltinOperator(
-          e.operator,
-          e.arguments.skip(1).toList(),
-          e.sourceInformation);
+          e.operator, e.arguments.skip(1).toList(), e.sourceInformation);
     } else {
       return e.arguments[1];
     }
   }
 
   void destroyVariableUse(VariableUse node) {
     --node.variable.readCount;
   }
 
   Expression visitSetField(SetField node) {
@@ skipping 132 matching lines @@
     }
   }
 
   /// If [operator] is a commutable binary operator, returns the commuted
   /// operator, possibly the operator itself, otherwise returns `null`.
   BuiltinOperator commuteBinaryOperator(BuiltinOperator operator) {
     if (isSymmetricOperator(operator)) {
       // Symmetric operators are their own commutes.
       return operator;
     }
-    switch(operator) {
-      case BuiltinOperator.NumLt: return BuiltinOperator.NumGt;
-      case BuiltinOperator.NumLe: return BuiltinOperator.NumGe;
-      case BuiltinOperator.NumGt: return BuiltinOperator.NumLt;
-      case BuiltinOperator.NumGe: return BuiltinOperator.NumLe;
-      default: return null;
+    switch (operator) {
+      case BuiltinOperator.NumLt:
+        return BuiltinOperator.NumGt;
+      case BuiltinOperator.NumLe:
+        return BuiltinOperator.NumGe;
+      case BuiltinOperator.NumGt:
+        return BuiltinOperator.NumLt;
+      case BuiltinOperator.NumGe:
+        return BuiltinOperator.NumLe;
+      default:
+        return null;
     }
   }
 
   /// Built-in binary operators are commuted when it is safe and can enable an
   /// assignment propagation. For example:
   ///
   ///    var x = foo();
   ///    var y = bar();
   ///    var z = y < x;
   ///
   ///      ==>
   ///
   ///    var z = foo() > bar();
   ///
   /// foo() must be evaluated before bar(), so the propagation is only possible
   /// by commuting the operator.
   Expression visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
     if (!environment.isEmpty && getLeftHand(environment.last) != null) {
       Variable propagatableVariable = getLeftHand(environment.last);
       BuiltinOperator commuted = commuteBinaryOperator(node.operator);
       if (commuted != null) {
         // Only binary operators can commute.
         assert(node.arguments.length == 2);
         Expression left = node.arguments[0];
         if (left is VariableUse && propagatableVariable == left.variable) {
           Expression right = node.arguments[1];
           if (right is This ||
               (right is VariableUse &&
-               propagatableVariable != right.variable &&
-               !constantEnvironment.containsKey(right.variable))) {
+                  propagatableVariable != right.variable &&
+                  !constantEnvironment.containsKey(right.variable))) {
             // An assignment can be propagated if we commute the operator.
             node.operator = commuted;
             node.arguments[0] = right;
             node.arguments[1] = left;
           }
         }
       }
     }
     // Avoid code like `p == (q.f = null)`. JS operators with a constant operand
     // can sometimes be compiled to a specialized instruction in the JS engine,
@@ skipping 12 matching lines @@
   /// and if [combine] returns E2 the unified statement is equivalence to [t].
   ///
   /// It is guaranteed that no side effects occur between the beginning of the
   /// statement and the position of the combined expression.
   ///
   /// Returns null if the statements are too different.
   ///
   /// If non-null is returned, the caller MUST discard [s] and [t] and use
   /// the returned statement instead.
   Statement combineStatementsInBranches(
-      Statement s,
-      Statement t,
-      Expression condition) {
+      Statement s, Statement t, Expression condition) {
     if (s is Return && t is Return) {
       return new Return(new Conditional(condition, s.value, t.value));
     }
     if (s is ExpressionStatement && t is ExpressionStatement) {
       // Combine the two expressions and the two successor statements.
       //
       //    C ? {E1 ; S1} : {E2 ; S2}
       //      ==>
       //    (C ? E1 : E2) : combine(S1, S2)
       //
@@ skipping 44 matching lines @@
   /// expression if something better can be done.
   ///
   /// In particular, assignments will be merged as follows:
   ///
   ///     C ? (v = E1) : (v = E2)
   ///       ==>
   ///     v = C ? E1 : E2
   ///
   /// The latter form is more compact and can also be inlined.
   CombinedExpressions combineAsConditional(
-      Expression s,
-      Expression t,
-      Expression condition) {
+      Expression s, Expression t, Expression condition) {
     if (s is Assign && t is Assign && s.variable == t.variable) {
       Expression values = new Conditional(condition, s.value, t.value);
       return new CombinedAssigns(s, t, new CombinedExpressions(values));
     }
     return new CombinedExpressions(new Conditional(condition, s, t));
   }
 
   /// Returns a statement equivalent to both [s] and [t], or null if [s] and
   /// [t] are incompatible.
   /// If non-null is returned, the caller MUST discard [s] and [t] and use
@@ skipping 11 matching lines @@
     }
     if (s is Continue && t is Continue && s.target == t.target) {
       --t.target.useCount; // Two continues become one.
       return s;
     }
     if (s is Return && t is Return) {
       CombinedExpressions values = combineExpressions(s.value, t.value);
       if (values != null) {
         // TODO(johnniwinther): Handle multiple source informations.
         SourceInformation sourceInformation = s.sourceInformation != null
-            ? s.sourceInformation : t.sourceInformation;
+            ? s.sourceInformation
+            : t.sourceInformation;
         return new Return(values.combined,
             sourceInformation: sourceInformation);
       }
     }
     if (s is ExpressionStatement && t is ExpressionStatement) {
       CombinedExpressions values =
           combineExpressions(s.expression, t.expression);
       if (values == null) return null;
       environment.add(values.combined);
       Variable leftHand = getLeftHand(values.combined);
@@ skipping 123 matching lines @@
     return polarity ? node.thenStatement : node.elseStatement;
   }
 
   void handleForeignCode(ForeignCode node) {
     // Some arguments will get inserted in a JS code template.  The arguments
     // will not always be evaluated (e.g. the second placeholder in the template
     // '# && #').
     bool isNullable(int position) => node.nullableArguments[position];
 
     int safeArguments =
-      PlaceholderSafetyAnalysis.analyze(node.codeTemplate.ast, isNullable);
+        PlaceholderSafetyAnalysis.analyze(node.codeTemplate.ast, isNullable);
     inEmptyEnvironment(() {
       for (int i = node.arguments.length - 1; i >= safeArguments; --i) {
         node.arguments[i] = visitExpression(node.arguments[i]);
       }
     });
     for (int i = safeArguments - 1; i >= 0; --i) {
       node.arguments[i] = visitExpression(node.arguments[i]);
     }
   }
 
@@ skipping 143 matching lines @@
 }
 
 /// Decrement the reference count for [e] if it is a variable use.
 void destroyPrimaryExpression(Expression e) {
   if (e is VariableUse) {
     --e.variable.readCount;
   } else {
     assert(e is This);
   }
 }