Generative constructors in the new dart backend.

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 11 matching lines @@
 // TODO(johnniwinther): Split into function/block state.
 class BuilderContext<T> {
   /// Builder context for the enclosing function, or null if the current
   /// function is not a local function.
   BuilderContext<T> _parent;
 
   /// Variables to be hoisted at the top of the current function.
   final List<VariableDeclaration> variables = <VariableDeclaration>[];
 
   /// Maps variables to their name.
-  final Map<tree.Variable, String> variableNames = <tree.Variable, String>{};
+  final Map<tree.Variable, String> variableNames;
 
   /// Maps local constants to their name.
   final Map<VariableElement, String> constantNames =
       <VariableElement, String>{};
 
   /// Variables that have had their declaration created.
   final Set<tree.Variable> declaredVariables = new Set<tree.Variable>();
 
   /// Variable names that have already been used. Used to avoid name clashes.
   final Set<String> usedVariableNames;
 
   /// Statements emitted by the most recent call to [visitStatement].
   List<T> _statementBuffer = <T>[];
 
   /// The element currently being emitted.
   ExecutableElement currentElement;
 
   /// Bookkeeping object needed to synthesize a variable declaration.
   final modelx.VariableList variableList
       = new modelx.VariableList(tree.Modifiers.EMPTY);
 
   /// Input to [visitStatement]. Denotes the statement that will execute next
   /// if the statements produced by [visitStatement] complete normally.
   /// Set to null if control will fall over the end of the method.
   tree.Statement fallthrough = null;
 
   /// Labels that could not be eliminated using fallthrough.
   final Set<tree.Label> _usedLabels = new Set<tree.Label>();
 
+  final bool inInitializer;
+
   /// The first dart_tree statement that is not converted to a variable
   /// initializer.
   tree.Statement firstStatement;
 
-  BuilderContext() : usedVariableNames = new Set<String>();
+  BuilderContext() : usedVariableNames = new Set<String>(),
+                     inInitializer = false,
+                     variableNames = <tree.Variable, String>{};
 
   BuilderContext.inner(BuilderContext<T> parent)
       : this._parent = parent,
-        usedVariableNames = parent.usedVariableNames;
+        usedVariableNames = parent.usedVariableNames,
+        inInitializer = false,
+        variableNames = <tree.Variable, String>{};
+
+  BuilderContext.initializer(BuilderContext<T> parent)
+      : this._parent = parent,
+        usedVariableNames = parent.usedVariableNames,
+        inInitializer = true,
+        variableNames =
+            new Map<tree.Variable, String>.from(parent.variableNames);
 
   // TODO(johnniwinther): Fully encapsulate handling of parameter, variable
   // and local funciton declarations.
   void addDeclaration(tree.Variable variable, [Expression initializer]) {
     assert(!declaredVariables.contains(variable));
     String name = getVariableName(variable);
     VariableDeclaration decl = new VariableDeclaration(name, initializer);
     decl.element = variable.element;
     declaredVariables.add(variable);
     variables.add(decl);
   }
 
   /// Generates a name for the given variable and synthesizes an element for it,
   /// if necessary.
   String getVariableName(tree.Variable variable) {
     // If the variable belongs to an enclosing function, ask the parent emitter
     // for the variable name.
-    if (variable.host != currentElement) {
+    if (!inInitializer && variable.host != currentElement) {
       return _parent.getVariableName(variable);
     }
 
     // Get the name if we already have one.
     String name = variableNames[variable];
     if (name != null) {
       return name;
     }
 
     // Synthesize a variable name that isn't used elsewhere.
@@ skipping 86 matching lines @@
 /// Translates the dart_tree IR to Dart backend AST.
 /// An instance of this class should only be used once; a fresh emitter
 /// must be created for each function to be emitted.
 class ASTEmitter
     extends tree.Visitor1<dynamic, Expression, BuilderContext<Statement>> {
 
   ExecutableDefinition emit(tree.ExecutableDefinition definition,
                             BuilderContext<Statement> context) {
     if (definition is tree.FieldDefinition) {
       return emitField(definition, context);
+    } else if (definition is tree.ConstructorDefinition) {
+      return emitConstructor(definition, context);
     }
     assert(definition is tree.FunctionDefinition);
     return emitFunction(definition, context);
   }
 
   FieldDefinition emitField(tree.FieldDefinition definition,
                             BuilderContext<Statement> context) {
     context.currentElement = definition.element;
     Expression initializer;
     if (definition.hasInitializer) {
@@ skipping 27 matching lines @@
         return onlyStatement.expression;
       }
     }
     Statement body = new Block(bodyParts);
     FunctionExpression function =
         new FunctionExpression(new Parameters([]), body);
     function.element = null;
     return new CallFunction(function, []);
   }
 
+  FunctionExpression emitConstructor(tree.ConstructorDefinition definition,
+                                     BuilderContext<Statement> context) {
+    context.currentElement = definition.element;
+
+    Parameters parameters = emitRootParameters(definition, context);
+
+    // Declare parameters.
+    for (tree.Variable param in definition.parameters) {
+      context.variableNames[param] = param.element.name;
+      context.usedVariableNames.add(param.element.name);
+      context.declaredVariables.add(param);
+    }
+
+    List<Expression> initializers;
+    Statement body;
+
+    if (!definition.isAbstract) {
+      initializers =
+          definition.initializers.map((tree.Initializer initializer) {
+        return visitExpression(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);
+        }
+      }
+
+      // 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 = emitConstant(constDecl.expression, context);
+        VariableDeclaration decl = new VariableDeclaration(name, value);
+        decl.element = constDecl.element;
+        constants.add(decl);
+      }
+
+      List<Statement> bodyParts = [];
+      if (constants.length > 0) {
+        bodyParts.add(new VariableDeclarations(constants, isConst: true));
+      }
+      if (context.variables.length > 0) {
+        bodyParts.add(new VariableDeclarations(context.variables));
+      }
+      bodyParts.addAll(context.statements);
+
+      body = new Block(bodyParts);
+
+    }
+    FunctionType functionType = context.currentElement.type;
+
+    return new ConstructorDefinition(
+        parameters,
+        body,
+        initializers,
+        context.currentElement.name, definition.isConst)
+        ..element = context.currentElement;
+  }
+
   FunctionExpression emitFunction(tree.FunctionDefinition definition,
                                   BuilderContext<Statement> context) {
     context.currentElement = definition.element;
 
     Parameters parameters = emitRootParameters(definition, context);
 
     // Declare parameters.
     for (tree.Variable param in definition.parameters) {
       context.variableNames[param] = param.element.name;
       context.usedVariableNames.add(param.element.name);
       context.declaredVariables.add(param);
     }
 
     Statement body;
     if (definition.isAbstract) {
       body = new EmptyStatement();
     } else {
       context.firstStatement = definition.body;
       visitStatement(definition.body, context);
-      context.removeTrailingReturn((Statement statement) {
-        if (statement is Return) {
-          Expression expr = statement.expression;
-          if (expr is Literal && expr.value.isNull) {
-            return true;
-          }
-        }
-        return false;
-      });
+      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);
         }
       }
 
@@ skipping 26 matching lines @@
     return new FunctionExpression(
         parameters,
         body,
         name: context.currentElement.name,
         returnType: emitOptionalType(functionType.returnType),
         isGetter: context.currentElement.isGetter,
         isSetter: context.currentElement.isSetter)
         ..element = context.currentElement;
   }
 
+  bool _recognizeTrailingReturn(Statement statement) {
+    if (statement is Return) {
+      Expression expr = statement.expression;
+      if (expr == null || expr is Literal && expr.value.isNull) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /// TODO(johnniwinther): Remove this when issue 21283 has been resolved.
   int pseudoNameCounter = 0;
 
   Parameter emitParameter(DartType type,
                           BuilderContext<Statement> context,
                           {String name,
                            Element element,
                            ConstantExpression defaultValue}) {
     if (name == null && element != null) {
       name = element.name;
@@ skipping 203 matching lines @@
 
     context.addStatement(new ExpressionStatement(makeAssignment(
         visitVariable(stmt.variable, context),
         definition)));
     visitStatement(stmt.next, context);
   }
 
   @override
   void visitReturn(tree.Return stmt,
                    BuilderContext<Statement> context) {
-    Expression inner = visitExpression(stmt.value, context);
-    context.addStatement(new Return(inner));
+    if (context.currentElement.isGenerativeConstructor &&
+        !context.inInitializer) {
+      assert(() {
+        tree.Expression value = stmt.value;
+        return value is tree.Constant && value.value.isNull;
+      });
+      context.addStatement(new Return(null));
+    } else {
+      Expression inner = visitExpression(stmt.value, context);
+      context.addStatement(new Return(inner));
+    }
   }
 
   @override
   void visitBreak(tree.Break stmt,
                   BuilderContext<Statement> context) {
     tree.Statement fall = context.fallthrough;
     if (stmt.target.binding.next == fall) {
       // Fall through to break target
     } else if (fall is tree.Break && fall.target == stmt.target) {
       // Fall through to equivalent break
@@ skipping 93 matching lines @@
   }
 
   @override
   Expression visitTypeOperator(tree.TypeOperator exp,
                                BuilderContext<Statement> context) {
     return new TypeOperator(visitExpression(exp.receiver, context),
                             exp.operator,
                             createTypeAnnotation(exp.type));
   }
 
-  List<Argument> emitArguments(tree.Invoke exp,
-                               BuilderContext<Statement> context) {
-    List<tree.Expression> args = exp.arguments;
-    int positionalArgumentCount = exp.selector.positionalArgumentCount;
+  List<Argument> emitArguments(List<Expression> arguments,
+                               Selector selector) {
+    int positionalArgumentCount = selector.positionalArgumentCount;
     List<Argument> result = new List<Argument>.generate(positionalArgumentCount,
-        (i) => visitExpression(exp.arguments[i], context));
-    for (int i = 0; i < exp.selector.namedArgumentCount; ++i) {
-      result.add(new NamedArgument(exp.selector.namedArguments[i],
-          visitExpression(exp.arguments[positionalArgumentCount + i], context)));
+        (i) => arguments[i]);
+    for (int i = 0; i < selector.namedArgumentCount; ++i) {
+      result.add(new NamedArgument(selector.namedArguments[i],
+          arguments[positionalArgumentCount + i]));
     }
     return result;
   }
 
+  List<Expression> visitArgumentList(List<tree.Expression> arguments,
+                                     BuilderContext context) {
+    return arguments
+        .map((tree.Expression argument) => visitExpression(argument, context))
+        .toList();
+  }
+
   @override
   Expression visitInvokeStatic(tree.InvokeStatic exp,
                                BuilderContext<Statement> context) {
     switch (exp.selector.kind) {
       case SelectorKind.GETTER:
         return new Identifier(exp.target.name)..element = exp.target;
 
       case SelectorKind.SETTER:
         return new Assignment(
             new Identifier(exp.target.name)..element = exp.target,
             '=',
             visitExpression(exp.arguments[0], context));
 
       case SelectorKind.CALL:
         return new CallStatic(
-            null, exp.target.name, emitArguments(exp, context))
-                   ..element = exp.target;
+            null, exp.target.name,
+            emitArguments(visitArgumentList(exp.arguments, context),
+                          exp.selector))
+            ..element = exp.target;
 
       default:
         throw "Unexpected selector kind: ${exp.selector.kind}";
     }
   }
 
   Expression emitMethodCall(tree.Invoke exp, Receiver receiver,
                             BuilderContext<Statement> context) {
-    List<Argument> args = emitArguments(exp, context);
+    List<Argument> args =
+        emitArguments(visitArgumentList(exp.arguments, context), exp.selector);
     switch (exp.selector.kind) {
       case SelectorKind.CALL:
         if (exp.selector.name == "call") {
           return new CallFunction(receiver, args);
         }
         return new CallMethod(receiver, exp.selector.name, args);
 
       case SelectorKind.OPERATOR:
         if (args.length == 0) {
           String name = exp.selector.name;
@@ skipping 33 matching lines @@
 
   @override
   Expression visitInvokeSuperMethod(tree.InvokeSuperMethod exp,
                                     BuilderContext<Statement> context) {
     return emitMethodCall(exp, new SuperReceiver(), context);
   }
 
   @override
   Expression visitInvokeConstructor(tree.InvokeConstructor exp,
                                     BuilderContext<Statement> context) {
-    List args = emitArguments(exp, context);
+    List<Argument> args =
+        emitArguments(visitArgumentList(exp.arguments, context), exp.selector);
     FunctionElement constructor = exp.target;
     String name = constructor.name.isEmpty ? null : constructor.name;
     return new CallNew(createTypeAnnotation(exp.type),
                        args,
                        constructorName: name,
                        isConst: exp.constant != null)
                ..constructor = constructor
                ..dartType = exp.type;
   }
 
@@ skipping 54 matching lines @@
     FunctionDeclaration decl = new FunctionDeclaration(inner);
     context.declaredVariables.add(node.variable);
     context.addStatement(decl);
     visitStatement(node.next, context);
   }
 
   Expression emitConstant(ConstantExpression exp,
                           BuilderContext<Statement> context) {
     return const ConstantEmitter().visit(exp, context);
   }
+
+  List<Statement> buildInInitializerContext(tree.Statement root,
+                                     BuilderContext context) {
+    BuilderContext inner = new BuilderContext<Statement>.initializer(context);
+    inner.currentElement = context.currentElement;
+    visitStatement(root, inner);
+    List<Statement> bodyParts;
+    for (tree.Variable variable in inner.variableNames.keys) {
+      if (!context.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;
+    }
+    return bodyParts;
+  }
+
+  @override
+  Expression visitFieldInitializer(tree.FieldInitializer node,
+                                   BuilderContext<Statement> context) {
+    return new FieldInitializer(node.element,
+        ensureExpression(buildInInitializerContext(node.body, context)));
+  }
+
+  @override
+  Expression visitSuperInitializer(tree.SuperInitializer node,
+                                   BuilderContext<Statement> context) {
+    List<Argument> arguments = node.arguments.map((tree.Statement argument) {
+      return ensureExpression(buildInInitializerContext(argument, context));
+    }).toList();
+    return new SuperInitializer(node.target,
+                                emitArguments(arguments, node.selector));
+  }
 }
 
 /// Like [createTypeAnnotation] except the dynamic type is converted to null.
 TypeAnnotation emitOptionalType(DartType type) {
   if (type.treatAsDynamic) {
     return null;
   } else {
     return createTypeAnnotation(type);
   }
 }
@@ skipping 247 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;
 }