Assignment expressions in tree IR.

pkg/compiler/lib/src/dart_backend/backend_ast_emitter.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 backend_ast_emitter;
 
 import '../tree_ir/tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 124 matching lines @@
     if (variable.element == null || name != variable.element.name) {
       // TODO(johnniwinther): Replace by synthetic [Entity].
       variable.element = new _SyntheticLocalVariableElement(
           name,
           currentElement,
           variableList);
     }
     return name;
   }
 
+  /// Adds declarations for all variables that are still undeclared.
+  void declareRemainingVariables() {
+    // These variables can be referenced from other variable initializers if
+    // they are set by an assignment expression, so we declare variables before
+    // those with initializers.
+    List<VariableDeclaration> declarations = <VariableDeclaration>[];
+    for (tree.Variable variable in variableNames.keys) {
+      if (!declaredVariables.contains(variable)) {
+        String name = getVariableName(variable);
+        VariableDeclaration decl = new VariableDeclaration(name);
+        decl.element = variable.element;
+        declarations.add(decl);
+        declaredVariables.add(variable);
+      }
+    }
+    // Prepend all variables at once to avoid quadratic blowup.
+    variables.insertAll(0, declarations);
+  }
+
   String getConstantName(VariableElement element) {
     assert(element.kind == ElementKind.VARIABLE);
     if (element.enclosingElement != currentElement) {
       return _parent.getConstantName(element);
     }
     String name = constantNames[element];
     if (name != null) {
       return name;
     }
     String prefix = element.name;
@@ skipping 139 matching lines @@
         return visitInitializer(initializer, context);
       }).toList();
 
       context.firstStatement = definition.body;
       visitStatement(definition.body, context);
       context.removeTrailingReturn(_recognizeTrailingReturn);
 
       // Some of the variable declarations have already been added
       // if their first assignment could be pulled into the initializer.
       // Add the remaining variable declarations now.
-      for (tree.Variable variable in context.variableNames.keys) {
-        if (!context.declaredVariables.contains(variable)) {
-          context.addDeclaration(variable);
-        }
-      }
+      context.declareRemainingVariables();
 
       // Add constant declarations.
       List<VariableDeclaration> constants = <VariableDeclaration>[];
       for (ConstDeclaration constDecl in definition.localConstants) {
         if (!context.constantNames.containsKey(constDecl.element)) {
           continue; // Discard unused constants declarations.
         }
         String name = context.getConstantName(constDecl.element);
         Expression value =
             ConstantEmitter.createExpression(constDecl.expression, context);
@@ skipping 44 matching lines @@
     if (definition.isEmpty) {
       body = new EmptyStatement();
     } else {
       context.firstStatement = definition.body;
       visitStatement(definition.body, context);
       context.removeTrailingReturn(_recognizeTrailingReturn);
 
       // Some of the variable declarations have already been added
       // if their first assignment could be pulled into the initializer.
       // Add the remaining variable declarations now.
-      for (tree.Variable variable in context.variableNames.keys) {
-        if (!context.declaredVariables.contains(variable) &&
-            !context.handlerVariables.contains(variable)) {
-          context.addDeclaration(variable);
-        }
-      }
+      context.declareRemainingVariables();
 
       // Add constant declarations.
       List<VariableDeclaration> constants = <VariableDeclaration>[];
       for (ConstDeclaration constDecl in definition.localConstants) {
         if (!context.constantNames.containsKey(constDecl.element)) {
           continue; // Discard unused constants declarations.
         }
         String name = context.getConstantName(constDecl.element);
         Expression value =
             ConstantEmitter.createExpression(constDecl.expression, context);
@@ skipping 102 matching lines @@
     if (context.removeUsedLabel(label)) {
       context.addStatement(new LabeledStatement(label.name, statement));
     } else {
       context.addStatement(statement);
     }
   }
 
   @override
   void visitExpressionStatement(tree.ExpressionStatement stmt,
                                 BuilderContext<Statement> context) {
+    if (stmt.expression is tree.Assign) {
+      emitAssignStatement(stmt.expression, stmt, context);
+      return;
+    }
     Expression e = visitExpression(stmt.expression, context);
     context.addStatement(new ExpressionStatement(e));
+    visitStatement(stmt.next, context);
+  }
 
-    visitStatement(stmt.next, context);
+  @override
+  void visitVariableDeclaration(tree.VariableDeclaration node,
+                                BuilderContext<Statement> context) {
+    Expression value = visitExpression(node.value, context);
+    String name = context.getVariableName(node.variable);
+    VariableDeclaration decl = new VariableDeclaration(name, value)
+                                   ..element = node.variable.element;
+    context.declaredVariables.add(node.variable);
+    context.addStatement(new VariableDeclarations([decl]));
+    visitStatement(node.next, context);
   }
 
   @override
   void visitLabeledStatement(tree.LabeledStatement stmt,
                              BuilderContext<Statement> context) {
     Block block = visitInSubContext(stmt.body, context, fallthrough: stmt.next);
     addLabeledStatement(stmt.label, block, context);
 
     visitStatement(stmt.next, context);
   }
 
   bool isNullLiteral(Expression exp) => exp is Literal && exp.value.isNull;
 
-  @override
-  void visitAssign(tree.Assign stmt,
-                   BuilderContext<Statement> context) {
+  void emitAssignStatement(tree.Assign assign,
+                           tree.Statement statement,
+                           BuilderContext<Statement> context) {
     // Try to emit a local function declaration. This is useful for functions
     // that may occur in expression context, but could not be inlined anywhere.
-    if (stmt.variable.element is FunctionElement &&
-        stmt.value is tree.FunctionExpression &&
-        !context.declaredVariables.contains(stmt.variable) &&
-        stmt.variable.writeCount == 1) {
-      tree.FunctionExpression functionExp = stmt.value;
+    if (assign.variable.element is FunctionElement &&
+        assign.value is tree.FunctionExpression &&
+        !context.declaredVariables.contains(assign.variable) &&
+        assign.variable.writeCount == 1) {
+      tree.FunctionExpression functionExp = assign.value;
       FunctionExpression function =
           makeSubFunction(functionExp.definition, context);
       FunctionDeclaration decl = new FunctionDeclaration(function);
       context.addStatement(decl);
-      context.declaredVariables.add(stmt.variable);
+      context.declaredVariables.add(assign.variable);
 
-      visitStatement(stmt.next, context);
+      visitStatement(statement.next, context);
       return;
     }
 
-    bool isFirstOccurrence = (context.variableNames[stmt.variable] == null);
-    bool isDeclaredHere = stmt.variable.host == context.currentElement;
-    String name = context.getVariableName(stmt.variable);
-    Expression definition = visitExpression(stmt.value, context);
+    Expression definition = visitExpression(assign.value, context);
+    bool isFirstOccurrence = (context.variableNames[assign.variable] == null);
+    bool isDeclaredHere = assign.variable.host == context.currentElement;
+    bool isFirstStatement = context.firstStatement == statement;
+    String name = context.getVariableName(assign.variable);
 
     // Try to pull into initializer.
-    if (context.firstStatement == stmt && isFirstOccurrence && isDeclaredHere) {
+    if (isFirstStatement && isFirstOccurrence && isDeclaredHere) {
       if (isNullLiteral(definition)) definition = null;
-      context.addDeclaration(stmt.variable, definition);
-      context.firstStatement = stmt.next;
-      visitStatement(stmt.next, context);
-      return;
-    }
-
-    // Emit a variable declaration if we are required to do so.
-    // For captured variables, this ensures that a fresh variable is created.
-    if (stmt.isDeclaration) {
-      assert(isFirstOccurrence);
-      assert(isDeclaredHere);
-      if (isNullLiteral(definition)) definition = null;
-      VariableDeclaration decl = new VariableDeclaration(name, definition)
-                                     ..element = stmt.variable.element;
-      context.declaredVariables.add(stmt.variable);
-      context.addStatement(new VariableDeclarations([decl]));
-      visitStatement(stmt.next, context);
+      context.addDeclaration(assign.variable, definition);
+      context.firstStatement = statement.next;
+      visitStatement(statement.next, context);
       return;
     }
 
     context.addStatement(new ExpressionStatement(makeAssignment(
-        context.makeVariableAccess(stmt.variable),
+        context.makeVariableAccess(assign.variable),
         definition)));
-    visitStatement(stmt.next, context);
+    visitStatement(statement.next, context);
   }
 
   @override
   void visitReturn(tree.Return stmt,
                    BuilderContext<Statement> context) {
     if (context.currentElement.isGenerativeConstructor &&
         !context.inInitializer) {
       assert(() {
         tree.Expression value = stmt.value;
         return value is tree.Constant && value.value.isNull;
@@ skipping 66 matching lines @@
   void visitTry(tree.Try stmt,
                 BuilderContext<Statement> context) {
     Block tryBody = visitInSubContext(stmt.tryBody, context);
     Block catchBody = visitInSubContext(stmt.catchBody, context);
     CatchBlock catchBlock;
     tree.Variable exceptionVariable = stmt.catchParameters[0];
     context.handlerVariables.add(exceptionVariable);
     VariableDeclaration exceptionParameter =
         new VariableDeclaration(context.getVariableName(exceptionVariable));
     exceptionParameter.element = exceptionVariable.element;
+    stmt.catchParameters.forEach(context.declaredVariables.add);
     if (stmt.catchParameters.length == 2) {
       tree.Variable stackTraceVariable = stmt.catchParameters[1];
       context.handlerVariables.add(stackTraceVariable);
       VariableDeclaration stackTraceParameter =
           new VariableDeclaration(context.getVariableName(stackTraceVariable));
       stackTraceParameter.element = stackTraceVariable.element;
       catchBlock = new CatchBlock(catchBody,
           exceptionVar: exceptionParameter,
           stackVar: stackTraceParameter);
     } else {
@@ skipping 205 matching lines @@
                       BuilderContext<Statement> context) {
     return new UnaryOperator('!', visitExpression(exp.operand, context));
   }
 
   @override
   Expression visitVariableUse(tree.VariableUse exp,
                               BuilderContext<Statement> context) {
     return context.makeVariableAccess(exp.variable);
   }
 
+  @override
+  Expression visitAssign(tree.Assign node, BuilderContext<Statement> context) {
+    // This is called only when an assignment occurs in expression context.
+    return makeAssignment(
+        context.makeVariableAccess(node.variable),
+        visitExpression(node.value, context));
+  }
+
   FunctionExpression makeSubFunction(tree.FunctionDefinition function,
                                      BuilderContext<Statement> context) {
     return visitFunctionDefinition(function,
         new BuilderContext<Statement>.inner(context));
   }
 
   @override
   Expression visitFunctionExpression(tree.FunctionExpression exp,
                                      BuilderContext<Statement> context) {
     return makeSubFunction(exp.definition, context)..name = null;
   }
 
   @override
   void visitFunctionDeclaration(tree.FunctionDeclaration node,
                                 BuilderContext<Statement> context) {
     assert(context.variableNames[node.variable] == null);
     String name = context.getVariableName(node.variable);
     FunctionExpression inner = makeSubFunction(node.definition, context);
     inner.name = name;
     FunctionDeclaration decl = new FunctionDeclaration(inner);
     context.declaredVariables.add(node.variable);
     context.addStatement(decl);
     visitStatement(node.next, context);
   }
 
   List<Statement> buildInInitializerContext(tree.Statement root,
-                                     BuilderContext context) {
+                                            BuilderContext context) {
     BuilderContext inner = new BuilderContext<Statement>.initializer(context);
     inner.currentElement = context.currentElement;
+    inner.firstStatement = root;
     visitStatement(root, inner);
     List<Statement> bodyParts;
     for (tree.Variable variable in inner.variableNames.keys) {
-      if (!context.declaredVariables.contains(variable)) {
+      if (!context.declaredVariables.contains(variable) &&
+          !inner.declaredVariables.contains(variable)) {
         inner.addDeclaration(variable);
       }
     }
     if (inner.variables.length > 0) {
       bodyParts = new List<Statement>();
       bodyParts.add(new VariableDeclarations(inner.variables));
       bodyParts.addAll(inner.statements);
     } else {
       bodyParts = inner.statements;
     }
@@ skipping 359 matching lines @@
     environment = oldEnvironment;
     shadowedParameters = oldShadow;
 
     for (int i=0; i<definition.parameters.length; i++) {
       tree.Variable param = definition.parameters[i];
       if (hasShadowedUse.remove(param)) {
         tree.Variable newParam = new tree.Variable(definition.element,
             param.element);
         definition.parameters[i] = newParam;
         definition.replaceEachBody((tree.Statement body) {
-          return new tree.Assign(param, new tree.VariableUse(newParam), body);
+          return tree.Assign.makeStatement(
+              param,
+              new tree.VariableUse(newParam),
+              body);
         });
         newParam.writeCount = 1; // Being a parameter counts as a write.
         param.writeCount--; // Not a parameter anymore.
       }
     }
   }
 
   @override
   void visitInnerFunction(tree.FunctionDefinition definition) {
     unshadowFunction(definition);
@@ skipping 19 matching lines @@
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
 
   LibraryElement get implementationLibrary => enclosingElement.library;
 }