dartfmt pkg/compiler

pkg/compiler/lib/src/tree_ir/optimization/logical_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.logical_rewriter;
 
 import '../tree_ir_nodes.dart';
 import 'optimization.dart' show Pass;
 import '../../constants/values.dart' as values;
 
@@ skipping 34 matching lines @@
 /// Conditionals are tricky to rewrite when they occur out of boolean context.
 /// Here we must apply more conservative rules, such as:
 ///
 ///   x ? true : false  ==>  !!x
 ///
 /// If the possible falsy values of the condition are known, we can sometimes
 /// introduce a logical operator:
 ///
 ///   !x ? y : false  ==>  !x && y
 ///
-class LogicalRewriter extends RecursiveTransformer
-                      implements Pass {
+class LogicalRewriter extends RecursiveTransformer implements Pass {
   String get passName => 'Logical rewriter';
 
   @override
   void rewrite(FunctionDefinition node) {
     node.body = visitStatement(node.body);
   }
 
   final FallthroughStack fallthrough = new FallthroughStack();
 
   /// True if the given statement is equivalent to its fallthrough semantics.
   ///
   /// This means it will ultimately translate to an empty statement.
   bool isFallthrough(Statement node) {
     return node is Break && isFallthroughBreak(node) ||
-           node is Continue && isFallthroughContinue(node) ||
-           node is Return && isFallthroughReturn(node);
+        node is Continue && isFallthroughContinue(node) ||
+        node is Return && isFallthroughReturn(node);
   }
 
   bool isFallthroughBreak(Break node) {
     Statement target = fallthrough.target;
     return node.target.binding.next == target ||
-           target is Break && target.target == node.target;
+        target is Break && target.target == node.target;
   }
 
   bool isFallthroughContinue(Continue node) {
     Statement target = fallthrough.target;
     return node.target.binding == target ||
-           target is Continue && target.target == node.target;
+        target is Continue && target.target == node.target;
   }
 
   bool isFallthroughReturn(Return node) {
     return isNull(node.value) && fallthrough.target == null;
   }
 
   bool isTerminator(Statement node) {
     return (node is Jump || node is Return) && !isFallthrough(node) ||
-           (node is ExpressionStatement && node.next is Unreachable) ||
-           node is Throw;
+        (node is ExpressionStatement && node.next is Unreachable) ||
+        node is Throw;
   }
 
   Statement visitIf(If node) {
     // If one of the branches is empty (i.e. just a fallthrough), then that
     // branch should preferably be the 'else' so we won't have to print it.
     // In other words, we wish to perform this rewrite:
     //   if (E) {} else {S}
     //     ==>
     //   if (!E) {S}
     // In the tree language, empty statements do not exist yet, so we must check
@@ skipping 11 matching lines @@
     const int THEN = 1;
     const int NEITHER = 0;
     const int ELSE = -1;
     int bestThenBranch = NEITHER;
     if (isFallthrough(node.thenStatement) &&
         !isFallthrough(node.elseStatement)) {
       // Put the empty statement in the 'else' branch.
       // if (E) {} else {S} ==> if (!E) {S}
       bestThenBranch = ELSE;
     } else if (isFallthrough(node.elseStatement) &&
-               !isFallthrough(node.thenStatement)) {
+        !isFallthrough(node.thenStatement)) {
       // Keep the empty statement in the 'else' branch.
       // if (E) {S} else {}
       bestThenBranch = THEN;
     } else if (thenHasFallthrough && !elseHasFallthrough) {
       // Put abrupt termination in the 'then' branch to omit 'else'.
       // if (E) {S1} else {S2; return v} ==> if (!E) {S2; return v}; S1
       bestThenBranch = ELSE;
     } else if (!thenHasFallthrough && elseHasFallthrough) {
       // Keep abrupt termination in the 'then' branch to omit 'else'.
       // if (E) {S1; return v}; S2
       bestThenBranch = THEN;
     } else if (isTerminator(node.elseStatement) &&
-               !isTerminator(node.thenStatement)) {
+        !isTerminator(node.thenStatement)) {
       // Put early termination in the 'then' branch to reduce nesting depth.
       // if (E) {S}; return v ==> if (!E) return v; S
       bestThenBranch = ELSE;
     } else if (isTerminator(node.thenStatement) &&
-               !isTerminator(node.elseStatement)) {
+        !isTerminator(node.elseStatement)) {
       // Keep early termination in the 'then' branch to reduce nesting depth.
       // if (E) {return v;} S
       bestThenBranch = THEN;
     }
 
     // Swap branches if 'else' is better as 'then'
     if (bestThenBranch == ELSE) {
       node.condition = new Not(node.condition);
       Statement tmp = node.thenStatement;
       node.thenStatement = node.elseStatement;
       node.elseStatement = tmp;
     }
 
     // If neither branch is better, eliminate a negation in the condition
     // if (!E) S1 else S2
     //   ==>
     // if (E) S2 else S1
     node.condition = makeCondition(node.condition, true,
-                                   liftNots: bestThenBranch == NEITHER);
+        liftNots: bestThenBranch == NEITHER);
     if (bestThenBranch == NEITHER && node.condition is Not) {
       node.condition = (node.condition as Not).operand;
       Statement tmp = node.thenStatement;
       node.thenStatement = node.elseStatement;
       node.elseStatement = tmp;
     }
 
     return node;
   }
 
@@ skipping 88 matching lines @@
     // x ? false : true --> !x
     if (isFalse(node.thenExpression) && isTrue(node.elseExpression)) {
       return toBoolean(makeCondition(node.condition, false, liftNots: false));
     }
 
     // x ? y : false ==> x && y  (if x is truthy or false)
     // x ? y : null  ==> x && y  (if x is truthy or null)
     // x ? y : 0     ==> x && y  (if x is truthy or zero) (and so on...)
     if (matchesFalsyValue(node.condition, getConstant(node.elseExpression))) {
       return new LogicalOperator.and(
-          visitExpression(node.condition),
-          node.thenExpression);
+          visitExpression(node.condition), node.thenExpression);
     }
     // x ? true : y ==> x || y  (if x is falsy or true)
     // x ? 1    : y ==> x || y  (if x is falsy or one) (and so on...)
     if (matchesTruthyValue(node.condition, getConstant(node.thenExpression))) {
       return new LogicalOperator.or(
-          visitExpression(node.condition),
-          node.elseExpression);
+          visitExpression(node.condition), node.elseExpression);
     }
     // x ? y : true ==> !x || y
     if (isTrue(node.elseExpression)) {
       return new LogicalOperator.or(
           toBoolean(makeCondition(node.condition, false, liftNots: false)),
           node.thenExpression);
     }
     // x ? false : y ==> !x && y
     if (isFalse(node.thenExpression)) {
       return new LogicalOperator.and(
@@ skipping 30 matching lines @@
     node.right = visitExpression(node.right);
     return node;
   }
 
   /// True if the given expression is known to evaluate to a boolean.
   /// This will not recursively traverse [Conditional] expressions, but if
   /// applied to the result of [visitExpression] conditionals will have been
   /// rewritten anyway.
   bool isBooleanValued(Expression e) {
     return isTrue(e) ||
-           isFalse(e) ||
-           e is Not ||
-           e is LogicalOperator && isBooleanValuedLogicalOperator(e) ||
-           e is ApplyBuiltinOperator && operatorReturnsBool(e.operator) ||
-           e is TypeOperator && isBooleanValuedTypeOperator(e);
+        isFalse(e) ||
+        e is Not ||
+        e is LogicalOperator && isBooleanValuedLogicalOperator(e) ||
+        e is ApplyBuiltinOperator && operatorReturnsBool(e.operator) ||
+        e is TypeOperator && isBooleanValuedTypeOperator(e);
   }
 
   bool isBooleanValuedLogicalOperator(LogicalOperator e) {
     return isBooleanValued(e.left) && isBooleanValued(e.right);
   }
 
   /// True if the given operator always returns `true` or `false`.
   bool operatorReturnsBool(BuiltinOperator operator) {
     switch (operator) {
       case BuiltinOperator.StrictEq:
@@ skipping 15 matching lines @@
         return false;
     }
   }
 
   bool isBooleanValuedTypeOperator(TypeOperator e) {
     return e.isTypeTest;
   }
 
   BuiltinOperator negateBuiltin(BuiltinOperator operator) {
     switch (operator) {
-      case BuiltinOperator.StrictEq: return BuiltinOperator.StrictNeq;
-      case BuiltinOperator.StrictNeq: return BuiltinOperator.StrictEq;
-      case BuiltinOperator.LooseEq: return BuiltinOperator.LooseNeq;
-      case BuiltinOperator.LooseNeq: return BuiltinOperator.LooseEq;
-      case BuiltinOperator.IsNumber: return BuiltinOperator.IsNotNumber;
-      case BuiltinOperator.IsNotNumber: return BuiltinOperator.IsNumber;
-      case BuiltinOperator.IsInteger: return BuiltinOperator.IsNotInteger;
-      case BuiltinOperator.IsNotInteger: return BuiltinOperator.IsInteger;
+      case BuiltinOperator.StrictEq:
+        return BuiltinOperator.StrictNeq;
+      case BuiltinOperator.StrictNeq:
+        return BuiltinOperator.StrictEq;
+      case BuiltinOperator.LooseEq:
+        return BuiltinOperator.LooseNeq;
+      case BuiltinOperator.LooseNeq:
+        return BuiltinOperator.LooseEq;
+      case BuiltinOperator.IsNumber:
+        return BuiltinOperator.IsNotNumber;
+      case BuiltinOperator.IsNotNumber:
+        return BuiltinOperator.IsNumber;
+      case BuiltinOperator.IsInteger:
+        return BuiltinOperator.IsNotInteger;
+      case BuiltinOperator.IsNotInteger:
+        return BuiltinOperator.IsInteger;
       case BuiltinOperator.IsUnsigned32BitInteger:
         return BuiltinOperator.IsNotUnsigned32BitInteger;
       case BuiltinOperator.IsNotUnsigned32BitInteger:
         return BuiltinOperator.IsUnsigned32BitInteger;
 
       // Because of NaN, these do not have a negated form.
       case BuiltinOperator.NumLt:
       case BuiltinOperator.NumLe:
       case BuiltinOperator.NumGt:
       case BuiltinOperator.NumGe:
@@ skipping 10 matching lines @@
       return e;
     else
       return new Not(new Not(e));
   }
 
   /// Creates an equivalent boolean expression. The expression must occur in a
   /// context where its result is immediately subject to boolean conversion.
   /// If [polarity] if false, the negated condition will be created instead.
   /// If [liftNots] is true (default) then Not expressions will be lifted toward
   /// the root of the condition so they can be eliminated by the caller.
-  Expression makeCondition(Expression e, bool polarity, {bool liftNots:true}) {
+  Expression makeCondition(Expression e, bool polarity, {bool liftNots: true}) {
     if (e is Not) {
       // !!E ==> E
       return makeCondition(e.operand, !polarity, liftNots: liftNots);
     }
     if (e is LogicalOperator) {
       // If polarity=false, then apply the rewrite !(x && y) ==> !x || !y
       e.left = makeCondition(e.left, polarity);
       e.right = makeCondition(e.right, polarity);
       if (!polarity) {
         e.isAnd = !e.isAnd;
@@ skipping 26 matching lines @@
       // x ? true : false ==> x
       if (isTrue(e.thenExpression) && isFalse(e.elseExpression)) {
         return makeCondition(e.condition, true, liftNots: liftNots);
       }
       // x ? false : true ==> !x
       if (isFalse(e.thenExpression) && isTrue(e.elseExpression)) {
         return makeCondition(e.condition, false, liftNots: liftNots);
       }
       // x ? true : y  ==> x || y
       if (isTrue(e.thenExpression)) {
-        return makeOr(makeCondition(e.condition, true),
-                      e.elseExpression,
-                      liftNots: liftNots);
+        return makeOr(makeCondition(e.condition, true), e.elseExpression,
+            liftNots: liftNots);
       }
       // x ? false : y  ==> !x && y
       if (isFalse(e.thenExpression)) {
-        return makeAnd(makeCondition(e.condition, false),
-                       e.elseExpression,
-                       liftNots: liftNots);
+        return makeAnd(makeCondition(e.condition, false), e.elseExpression,
+            liftNots: liftNots);
       }
       // x ? y : true  ==> !x || y
       if (isTrue(e.elseExpression)) {
-        return makeOr(makeCondition(e.condition, false),
-                      e.thenExpression,
-                      liftNots: liftNots);
+        return makeOr(makeCondition(e.condition, false), e.thenExpression,
+            liftNots: liftNots);
       }
       // x ? y : false  ==> x && y
       if (isFalse(e.elseExpression)) {
-        return makeAnd(makeCondition(e.condition, true),
-                       e.thenExpression,
-                       liftNots: liftNots);
+        return makeAnd(makeCondition(e.condition, true), e.thenExpression,
+            liftNots: liftNots);
       }
 
       e.condition = makeCondition(e.condition, true);
 
       // !x ? y : z ==> x ? z : y
       if (e.condition is Not) {
         e.condition = (e.condition as Not).operand;
         Expression tmp = e.thenExpression;
         e.thenExpression = e.elseExpression;
         e.elseExpression = tmp;
@@ skipping 69 matching lines @@
     } else if (e1 is Assign) {
       return e2 is VariableUse && e1.variable == e2.variable;
     }
     return false;
   }
 
   void destroyVariableUse(VariableUse node) {
     --node.variable.readCount;
   }
 }