Assignment expressions in tree IR.

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.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_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, GenericType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 24 matching lines @@
  */
 abstract class Node {
 }
 
 /**
  * The base class of [Expression]s.
  */
 abstract class Expression extends Node {
   accept(ExpressionVisitor v);
   accept1(ExpressionVisitor1 v, arg);
-
-  /// Temporary variable used by [StatementRewriter].
-  /// If set to true, this expression has already had enclosing assignments
-  /// propagated into its variables, and should not be processed again.
-  /// It is only set for expressions that are known to be in risk of redundant
-  /// processing.
-  bool processed = false;
 }
 
 abstract class Statement extends Node {
   Statement get next;
   void set next(Statement s);
   accept(StatementVisitor v);
   accept1(StatementVisitor1 v, arg);
 }
 
 /**
@@ skipping 74 matching lines @@
   VariableUse(this.variable) {
     variable.readCount++;
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitVariableUse(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitVariableUse(this, arg);
   }
 }
 
+class Assign extends Expression {
+  Variable variable;
+  Expression value;
+
+  Assign(this.variable, this.value) {
+    variable.writeCount++;
+  }
+
+  accept(ExpressionVisitor v) => v.visitAssign(this);
+  accept1(ExpressionVisitor1 v, arg) => v.visitAssign(this, arg);
+
+  static ExpressionStatement makeStatement(Variable variable,
+                                           Expression value,
+                                           [Statement next]) {
+    return new ExpressionStatement(new Assign(variable, value), next);
+  }
+}
+
 /**
  * Common interface for invocations with arguments.
  */
 abstract class Invoke {
   List<Expression> get arguments;
   Selector get selector;
 }
 
 /**
  * A call to a static function or getter/setter to a static field.
@@ skipping 356 matching lines @@
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Continue(this.target) {
     ++target.useCount;
   }
 
   accept(StatementVisitor visitor) => visitor.visitContinue(this);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitContinue(this, arg);
 }
 
-/**
- * An assignments of an [Expression] to a [Variable].
- *
- * In contrast to the CPS-based IR, non-primitive expressions can be assigned
- * to variables.
- */
-class Assign extends Statement {
-  Statement next;
+/// Declares a captured [variable] with an initial [value].
+///
+/// All uses of the variable must be inside the [next] statement.
+class VariableDeclaration extends Statement implements DartSpecificNode {
   Variable variable;
   Expression value;
+  Statement next;
 
-  /// If true, this assignes to a fresh variable scoped to the [next]
-  /// statement.
-  ///
-  /// Variable declarations themselves are hoisted to function level.
-  bool isDeclaration;
-
-  /// Creates an assignment to [variable] and updates its `writeCount`.
-  Assign(this.variable, this.value, this.next,
-         { this.isDeclaration: false }) {
-    variable.writeCount++;
+  VariableDeclaration(this.variable, this.value, this.next) {
+    assert(variable.isCaptured); // Because otherwise no declaration is needed.
+    ++variable.writeCount;
   }
 
-  bool get hasExactlyOneUse => variable.readCount == 1;
+  accept(StatementVisitor visitor) {
+    return visitor.visitVariableDeclaration(this);
+  }
 
-  accept(StatementVisitor visitor) => visitor.visitAssign(this);
-  accept1(StatementVisitor1 visitor, arg) => visitor.visitAssign(this, arg);
+  accept1(StatementVisitor1 visitor, arg) {
+    return visitor.visitVariableDeclaration(this, arg);
+  }
 }
 
 /**
  * A return exit from the function.
  *
  * In contrast to the CPS-based IR, the return value is an arbitrary
  * expression.
  */
 class Return extends Statement {
   /// Should not be null. Use [Constant] with [NullConstantValue] for void
@@ skipping 252 matching lines @@
 class GetField extends Expression implements JsSpecificNode {
   Expression object;
   Element field;
 
   GetField(this.object, this.field);
 
   accept(ExpressionVisitor visitor) => visitor.visitGetField(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitGetField(this, arg);
 }
 
-class SetField extends Statement implements JsSpecificNode {
+class SetField extends Expression implements JsSpecificNode {
   Expression object;
   Element field;
   Expression value;
-  Statement next;
 
-  SetField(this.object, this.field, this.value, this.next);
+  SetField(this.object, this.field, this.value);
 
-  accept(StatementVisitor visitor) => visitor.visitSetField(this);
-  accept1(StatementVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
+  accept(ExpressionVisitor visitor) => visitor.visitSetField(this);
+  accept1(ExpressionVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
 }
 
 class ReifyRuntimeType extends Expression implements JsSpecificNode {
   Expression value;
 
   ReifyRuntimeType(this.value);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitReifyRuntimeType(this);
   }
@@ skipping 32 matching lines @@
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitTypeExpression(this, arg);
   }
 }
 
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression node) => node.accept(this);
   E visitVariableUse(VariableUse node);
+  E visitAssign(Assign node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
   E visitReifyTypeVar(ReifyTypeVar node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitFunctionExpression(FunctionExpression node);
   E visitGetField(GetField node);
   E visitCreateBox(CreateBox node);
   E visitCreateInstance(CreateInstance node);
   E visitReifyRuntimeType(ReifyRuntimeType node);
   E visitReadTypeVariable(ReadTypeVariable node);
   E visitTypeExpression(TypeExpression node);
+  E visitSetField(SetField node);
 }
 
 abstract class ExpressionVisitor1<E, A> {
   E visitExpression(Expression node, A arg) => node.accept1(this, arg);
   E visitVariableUse(VariableUse node, A arg);
+  E visitAssign(Assign node, A arg);
   E visitInvokeStatic(InvokeStatic node, A arg);
   E visitInvokeMethod(InvokeMethod node, A arg);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node, A arg);
   E visitInvokeConstructor(InvokeConstructor node, A arg);
   E visitConcatenateStrings(ConcatenateStrings node, A arg);
   E visitConstant(Constant node, A arg);
   E visitThis(This node, A arg);
   E visitReifyTypeVar(ReifyTypeVar node, A arg);
   E visitConditional(Conditional node, A arg);
   E visitLogicalOperator(LogicalOperator node, A arg);
   E visitNot(Not node, A arg);
   E visitLiteralList(LiteralList node, A arg);
   E visitLiteralMap(LiteralMap node, A arg);
   E visitTypeOperator(TypeOperator node, A arg);
   E visitFunctionExpression(FunctionExpression node, A arg);
   E visitGetField(GetField node, A arg);
   E visitCreateBox(CreateBox node, A arg);
   E visitCreateInstance(CreateInstance node, A arg);
   E visitReifyRuntimeType(ReifyRuntimeType node, A arg);
   E visitReadTypeVariable(ReadTypeVariable node, A arg);
   E visitTypeExpression(TypeExpression node, A arg);
+  E visitSetField(SetField node, A arg);
 }
 
 abstract class StatementVisitor<S> {
   S visitStatement(Statement node) => node.accept(this);
   S visitLabeledStatement(LabeledStatement node);
-  S visitAssign(Assign node);
   S visitReturn(Return node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
   S visitWhileTrue(WhileTrue node);
   S visitWhileCondition(WhileCondition node);
   S visitFunctionDeclaration(FunctionDeclaration node);
+  S visitVariableDeclaration(VariableDeclaration node);
   S visitExpressionStatement(ExpressionStatement node);
   S visitTry(Try node);
-  S visitSetField(SetField node);
 }
 
 abstract class StatementVisitor1<S, A> {
   S visitStatement(Statement node, A arg) => node.accept1(this, arg);
   S visitLabeledStatement(LabeledStatement node, A arg);
-  S visitAssign(Assign node, A arg);
   S visitReturn(Return node, A arg);
   S visitBreak(Break node, A arg);
   S visitContinue(Continue node, A arg);
   S visitIf(If node, A arg);
   S visitWhileTrue(WhileTrue node, A arg);
   S visitWhileCondition(WhileCondition node, A arg);
   S visitFunctionDeclaration(FunctionDeclaration node, A arg);
+  S visitVariableDeclaration(VariableDeclaration node, A arg);
   S visitExpressionStatement(ExpressionStatement node, A arg);
   S visitTry(Try node, A arg);
-  S visitSetField(SetField node, A arg);
 }
 
 abstract class RootVisitor<T> {
   T visitRootNode(RootNode node) => node.accept(this);
   T visitFunctionDefinition(FunctionDefinition node);
   T visitConstructorDefinition(ConstructorDefinition node);
   T visitFieldDefinition(FieldDefinition node);
 }
 
 abstract class RootVisitor1<T, A> {
   T visitRootNode(RootNode node, A arg) => node.accept1(this, arg);
   T visitFunctionDefinition(FunctionDefinition node, A arg);
   T visitConstructorDefinition(ConstructorDefinition node, A arg);
   T visitFieldDefinition(FieldDefinition node, A arg);
 }
 
 abstract class InitializerVisitor<T> {
   T visitInitializer(Initializer node) => node.accept(this);
   T visitFieldInitializer(FieldInitializer node);
   T visitSuperInitializer(SuperInitializer node);
 }
 
+
 abstract class InitializerVisitor1<T, A> {
   T visitInitializer(Initializer node, A arg) => node.accept1(this, arg);
   T visitFieldInitializer(FieldInitializer node, A arg);
   T visitSuperInitializer(SuperInitializer node, A arg);
 }
 
 abstract class RecursiveVisitor implements StatementVisitor, ExpressionVisitor {
   visitExpression(Expression e) => e.accept(this);
   visitStatement(Statement s) => s.accept(this);
 
   visitInnerFunction(FunctionDefinition node);
 
-  visitVariable(Variable node) {}
+  visitVariable(Variable variable) {}
 
   visitVariableUse(VariableUse node) {
     visitVariable(node.variable);
   }
 
+  visitVariableDeclaration(VariableDeclaration node) {
+    visitVariable(node.variable);
+    visitStatement(node.next);
+  }
+
+  visitAssign(Assign node) {
+    visitVariable(node.variable);
+    visitExpression(node.value);
+  }
+
   visitInvokeStatic(InvokeStatic node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitInvokeMethod(InvokeMethod node) {
     visitExpression(node.receiver);
     node.arguments.forEach(visitExpression);
   }
 
   visitInvokeMethodDirectly(InvokeMethodDirectly node) {
@@ skipping 47 matching lines @@
 
   visitFunctionExpression(FunctionExpression node) {
     visitInnerFunction(node.definition);
   }
 
   visitLabeledStatement(LabeledStatement node) {
     visitStatement(node.body);
     visitStatement(node.next);
   }
 
-  visitAssign(Assign node) {
-    visitExpression(node.value);
-    visitVariable(node.variable);
-    visitStatement(node.next);
-  }
-
   visitReturn(Return node) {
     visitExpression(node.value);
   }
 
   visitBreak(Break node) {}
 
   visitContinue(Continue node) {}
 
   visitIf(If node) {
     visitExpression(node.condition);
@@ skipping 26 matching lines @@
     visitStatement(node.catchBody);
   }
 
   visitGetField(GetField node) {
     visitExpression(node.object);
   }
 
   visitSetField(SetField node) {
     visitExpression(node.object);
     visitExpression(node.value);
-    visitStatement(node.next);
   }
 
   visitCreateBox(CreateBox node) {
   }
 
   visitCreateInstance(CreateInstance node) {
     node.arguments.forEach(visitExpression);
     node.typeInformation.forEach(visitExpression);
   }
 
@@ skipping 22 matching lines @@
   }
 
   void _replaceExpressions(List<Expression> list) {
     for (int i = 0; i < list.length; i++) {
       list[i] = visitExpression(list[i]);
     }
   }
 
   visitVariableUse(VariableUse node) => node;
 
+  visitVariableDeclaration(VariableDeclaration node) {
+    node.next = visitStatement(node.next);
+    return node;
+  }
+
+  visitAssign(Assign node) {
+    node.value = visitExpression(node.value);
+    return node;
+  }
+
   visitInvokeStatic(InvokeStatic node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitInvokeMethod(InvokeMethod node) {
     node.receiver = visitExpression(node.receiver);
     _replaceExpressions(node.arguments);
     return node;
   }
@@ skipping 60 matching lines @@
     visitInnerFunction(node.definition);
     return node;
   }
 
   visitLabeledStatement(LabeledStatement node) {
     node.body = visitStatement(node.body);
     node.next = visitStatement(node.next);
     return node;
   }
 
-  visitAssign(Assign node) {
-    node.value = visitExpression(node.value);
-    node.next = visitStatement(node.next);
-    return node;
-  }
-
   visitReturn(Return node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
   visitBreak(Break node) => node;
 
   visitContinue(Continue node) => node;
 
   visitIf(If node) {
@@ skipping 34 matching lines @@
   }
 
   visitGetField(GetField node) {
     node.object = visitExpression(node.object);
     return node;
   }
 
   visitSetField(SetField node) {
     node.object = visitExpression(node.object);
     node.value = visitExpression(node.value);
-    node.next = visitStatement(node.next);
     return node;
   }
 
   visitCreateBox(CreateBox node) => node;
 
   visitCreateInstance(CreateInstance node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitReifyRuntimeType(ReifyRuntimeType node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
   visitReadTypeVariable(ReadTypeVariable node) {
     node.target = visitExpression(node.target);
     return node;
   }
 
   visitTypeExpression(TypeExpression node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 }