Overhaul tree IR visitor and rename IR classes.

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.
 
 part of tree_ir.optimization;
 
 /// Rewrites logical expressions to be more compact in the Tree IR.
 ///
 /// In this class an expression is said to occur in "boolean context" if
 /// its result is immediately applied to boolean conversion.
@@ skipping 36 matching lines @@
 ///
 ///   x ? y : false  ==>  x && y   (if y is known to be a boolean)
 ///
 /// The following sequence of rewrites demonstrates the merit of these rules:
 ///
 ///   x ? (y ? true : false) : false
 ///   x ? !!y : false   (double negation introduced by [toBoolean])
 ///   x && !!y          (!!y validated by [isBooleanValued])
 ///   x && y            (double negation removed by [putInBooleanContext])
 ///
-class LogicalRewriter extends Visitor<Statement, Expression> with PassMixin {
+class LogicalRewriter extends RecursiveTransformer
+                      implements Pass {
   String get passName => 'Logical rewriter';
 
+  @override
+  void rewrite(RootNode node) {
+    node.replaceEachBody(visitStatement);
+  }
+
   /// Statement to be executed next by natural fallthrough. Although fallthrough
   /// is not introduced in this phase, we need to reason about fallthrough when
   /// evaluating the benefit of swapping the branches of an [If].
   Statement fallthrough;
 
-  void rewriteExecutableDefinition(ExecutableDefinition root) {
-    root.body = visitStatement(root.body);
-  }
-
-  void rewriteConstructorDefinition(ConstructorDefinition root) {
-    if (root.isAbstract) return;
-    List<Initializer> initializers = root.initializers;
-    for (int i = 0; i < initializers.length; ++i) {
-      initializers[i] = visitExpression(initializers[i]);
-    }
-    root.body = visitStatement(root.body);
-  }
-
-  Expression visitFieldInitializer(FieldInitializer node) {
-    node.body = visitStatement(node.body);
-    return node;
-  }
-
-  visitSuperInitializer(SuperInitializer node) {
-    List<Statement> arguments = node.arguments;
-    for (int i = 0; i < arguments.length; ++i) {
-      arguments[i] = visitStatement(arguments[i]);
-    }
-    return node;
+  @override
+  void visitInnerFunction(FunctionDefinition node) {
+    new LogicalRewriter().rewrite(node);
   }
 
   Statement visitLabeledStatement(LabeledStatement node) {
     Statement savedFallthrough = fallthrough;
     fallthrough = node.next;
     node.body = visitStatement(node.body);
     fallthrough = savedFallthrough;
     node.next = visitStatement(node.next);
     return node;
   }
 
-  Statement visitAssign(Assign node) {
-    node.value = visitExpression(node.value);
-    node.next = visitStatement(node.next);
-    return node;
-  }
-
-  Statement visitReturn(Return node) {
-    node.value = visitExpression(node.value);
-    return node;
-  }
-
-  Statement visitBreak(Break node) {
-    return node;
-  }
-
-  Statement visitContinue(Continue node) {
-    return node;
-  }
-
   bool isFallthroughBreak(Statement node) {
     return node is Break && node.target.binding.next == fallthrough;
   }
 
   Statement visitIf(If node) {
     // If one of the branches is empty (i.e. just a fallthrough), then that
     // branch should preferrably be the 'else' so we won't have to print it.
     // In other words, we wish to perform this rewrite:
     //   if (E) {} else {S}
     //     ==>
@@ skipping 24 matching lines @@
     if (!emptyElse && node.condition is Not) {
       node.condition = (node.condition as Not).operand;
       Statement tmp = node.thenStatement;
       node.thenStatement = node.elseStatement;
       node.elseStatement = tmp;
     }
 
     return node;
   }
 
-  Statement visitWhileTrue(WhileTrue node) {
-    node.body = visitStatement(node.body);
-    return node;
-  }
-
   Statement visitWhileCondition(WhileCondition node) {
     node.condition = makeCondition(node.condition, true, liftNots: false);
     node.body = visitStatement(node.body);
     node.next = visitStatement(node.next);
     return node;
   }
 
-  Statement visitTry(Try node) {
-    node.tryBody = visitStatement(node.tryBody);
-    node.catchBody = visitStatement(node.catchBody);
-    return node;
-  }
-
-  Statement visitExpressionStatement(ExpressionStatement node) {
-    node.expression = visitExpression(node.expression);
-    node.next = visitStatement(node.next);
-    return node;
-  }
-
-  Expression visitVariableUse(VariableUse node) {
-    return node;
-  }
-
-  Expression visitInvokeStatic(InvokeStatic node) {
-    _rewriteList(node.arguments);
-    return node;
-  }
-
-  Expression visitInvokeMethod(InvokeMethod node) {
-    node.receiver = visitExpression(node.receiver);
-    _rewriteList(node.arguments);
-    return node;
-  }
-
-  Expression visitInvokeMethodDirectly(InvokeMethodDirectly node) {
-    node.receiver = visitExpression(node.receiver);
-    _rewriteList(node.arguments);
-    return node;
-  }
-
-  Expression visitInvokeConstructor(InvokeConstructor node) {
-    _rewriteList(node.arguments);
-    return node;
-  }
-
-  Expression visitConcatenateStrings(ConcatenateStrings node) {
-    _rewriteList(node.arguments);
-    return node;
-  }
-
-  Expression visitLiteralList(LiteralList node) {
-    _rewriteList(node.values);
-    return node;
-  }
-
-  Expression visitLiteralMap(LiteralMap node) {
-    node.entries.forEach((LiteralMapEntry entry) {
-      entry.key = visitExpression(entry.key);
-      entry.value = visitExpression(entry.value);
-    });
-    return node;
-  }
-
-  Expression visitTypeOperator(TypeOperator node) {
-    node.receiver = visitExpression(node.receiver);
-    return node;
-  }
-
-  Expression visitConstant(Constant node) {
-    return node;
-  }
-
-  Expression visitThis(This node) {
-    return node;
-  }
-
-  Expression visitReifyTypeVar(ReifyTypeVar node) {
-    return node;
-  }
-
-  Expression visitFunctionExpression(FunctionExpression node) {
-    new LogicalRewriter().rewrite(node.definition);
-    return node;
-  }
-
-  Statement visitFunctionDeclaration(FunctionDeclaration node) {
-    new LogicalRewriter().rewrite(node.definition);
-    node.next = visitStatement(node.next);
-    return node;
-  }
-
   Expression visitNot(Not node) {
     return toBoolean(makeCondition(node.operand, false, liftNots: false));
   }
 
   Expression visitConditional(Conditional node) {
     // node.condition will be visited after the then and else parts, because its
     // polarity depends on what rewrite we use.
     node.thenExpression = visitExpression(node.thenExpression);
     node.elseExpression = visitExpression(node.elseExpression);
 
@@ skipping 46 matching lines @@
 
     return node;
   }
 
   Expression visitLogicalOperator(LogicalOperator node) {
     node.left = makeCondition(node.left, true);
     node.right = makeCondition(node.right, true);
     return node;
   }
 
-  Statement visitSetField(SetField node) {
-    node.object = visitExpression(node.object);
-    node.value = visitExpression(node.value);
-    node.next = visitStatement(node.next);
-    return node;
-  }
-
-  Expression visitGetField(GetField node) {
-    node.object = visitExpression(node.object);
-    return node;
-  }
-
-  Expression visitCreateBox(CreateBox node) {
-    return node;
-  }
-
-  Expression visitCreateInstance(CreateInstance node) {
-    _rewriteList(node.arguments);
-    return node;
-  }
-
-  Expression visitReifyRuntimeType(ReifyRuntimeType node) {
-    node.value = visitExpression(node.value);
-    return node;
-  }
-
-  Expression visitReadTypeVariable(ReadTypeVariable node) {
-    node.target = visitExpression(node.target);
-    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;
   }
 
   /// Rewrite an expression that was originally processed in a non-boolean
   /// context.
@@ skipping 125 matching lines @@
   }
 
   Expression makeOr(Expression e1, Expression e2, {bool liftNots: true}) {
     if (e1 is Not && e2 is Not && liftNots) {
       return new Not(new LogicalOperator.and(e1.operand, e2.operand));
     } else {
       return new LogicalOperator.or(e1, e2);
     }
   }
 
-  /// Destructively updates each entry of [l] with the result of visiting it.
-  void _rewriteList(List<Expression> l) {
-    for (int i = 0; i < l.length; i++) {
-      l[i] = visitExpression(l[i]);
-    }
-  }
-
-  @override
-  Expression visitTypeExpression(TypeExpression node) {
-    _rewriteList(node.arguments);
-    return node;
-  }
 }