Expand ResolvedAst to handle synthetic constructors.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Names, Selectors;
 import '../common/tasks.dart' show CompilerTask;
@@ skipping 61 matching lines @@
       [this.builderCallback])
       : super(compiler);
 
   String get name => 'CPS builder';
 
   ir.FunctionDefinition buildNode(
       AstElement element, TypeMaskSystem typeMaskSystem) {
     return measure(() {
       bailoutMessage = null;
 
-      TreeElements elementsMapping = element.resolvedAst.elements;
+      ResolvedAst resolvedAst = element.resolvedAst;
       element = element.implementation;
       return reporter.withCurrentElement(element, () {
         SourceInformationBuilder sourceInformationBuilder =
             sourceInformationStrategy.createBuilderForContext(element);
 
-        IrBuilderVisitor builder = new IrBuilderVisitor(elementsMapping,
-            compiler, sourceInformationBuilder, typeMaskSystem);
+        IrBuilderVisitor builder = new IrBuilderVisitor(
+            resolvedAst, compiler, sourceInformationBuilder, typeMaskSystem);
         ir.FunctionDefinition irNode = builder.buildExecutable(element);
         if (irNode == null) {
           bailoutMessage = builder.bailoutMessage;
         } else if (builderCallback != null) {
           builderCallback(element, irNode);
         }
         return irNode;
       });
     });
   }
@@ skipping 16 matching lines @@
         BaseImplementationOfStaticsMixin<ir.Primitive, dynamic>,
         BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
         BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
         BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
         BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
         BaseImplementationOfCompoundsMixin<ir.Primitive, dynamic>,
         BaseImplementationOfSetIfNullsMixin<ir.Primitive, dynamic>,
         BaseImplementationOfIndexCompoundsMixin<ir.Primitive, dynamic>,
         BaseImplementationOfSuperIndexSetIfNullMixin<ir.Primitive, dynamic>
     implements SemanticSendVisitor<ir.Primitive, dynamic> {
-  final TreeElements elements;
+  final ResolvedAst resolvedAst;
   final Compiler compiler;
   final SourceInformationBuilder sourceInformationBuilder;
   final TypeMaskSystem typeMaskSystem;
 
   /// A map from try statements in the source to analysis information about
   /// them.
   ///
   /// The analysis information includes the set of variables that must be
   /// copied into [ir.MutableVariable]s on entry to the try and copied out on
   /// exit.
@@ skipping 11 matching lines @@
   // surrounding context, the free occurrences can be captured or become free
   // occurrences in the next outer delimited subexpression.
   //
   // Each nested visitor maintains a list that maps indexes of variables
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// Construct a top-level visitor.
-  IrBuilderVisitor(this.elements, this.compiler, this.sourceInformationBuilder,
-      this.typeMaskSystem);
+  IrBuilderVisitor(this.resolvedAst, this.compiler,
+      this.sourceInformationBuilder, this.typeMaskSystem);
+
+  TreeElements get elements => resolvedAst.elements;
 
   JavaScriptBackend get backend => compiler.backend;
   BackendHelpers get helpers => backend.helpers;
   DiagnosticReporter get reporter => compiler.reporter;
 
   String bailoutMessage = null;
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   @override
@@ skipping 16 matching lines @@
     // We translate a ClosureScope from closure.dart into IR builder's variant
     // because the IR builder should not depend on the synthetic elements
     // created in closure.dart.
     return new ClosureScope(closureClassMap.capturingScopes[node]);
   }
 
   /// Returns the [ClosureScope] for any function, possibly different from the
   /// one currently being built.
   ClosureScope getClosureScopeForFunction(FunctionElement function) {
     closure.ClosureClassMap map = compiler.closureToClassMapper
-        .computeClosureToClassMapping(function, function.node, elements);
+        .computeClosureToClassMapping(function.resolvedAst);
     return new ClosureScope(map.capturingScopes[function.node]);
   }
 
   /// If the current function is a nested function with free variables (or a
   /// captured reference to `this`), returns a [ClosureEnvironment]
   /// indicating how to access these.
   ClosureEnvironment getClosureEnvironment() {
     return new ClosureEnvironment(closureClassMap);
   }
 
@@ skipping 291 matching lines @@
       return irBuilder.makeFunctionDefinition(
           sourceInformationBuilder.buildVariableDeclaration());
     });
   }
 
   /// Make a visitor suitable for translating ASTs taken from [context].
   ///
   /// Every visitor can only be applied to nodes in one context, because
   /// the [elements] field is specific to that context.
   IrBuilderVisitor makeVisitorForContext(AstElement context) {
-    return new IrBuilderVisitor(context.resolvedAst.elements, compiler,
+    return new IrBuilderVisitor(context.resolvedAst, compiler,
         sourceInformationBuilder.forContext(context), typeMaskSystem);
   }
 
   /// Builds the IR for an [expression] taken from a different [context].
   ///
   /// Such expressions need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineExpression(AstElement context, ast.Expression expression) {
     IrBuilderVisitor visitor = makeVisitorForContext(context);
     return visitor.withBuilder(irBuilder, () => visitor.visit(expression));
@@ skipping 19 matching lines @@
   }
 
   /// In preparation of inlining (part of) [target], the [arguments] are moved
   /// into the environment bindings for the corresponding parameters.
   ///
   /// Defaults for optional arguments are evaluated in order to ensure
   /// all parameters are available in the environment.
   void loadArguments(ConstructorElement target, CallStructure call,
       List<ir.Primitive> arguments) {
     assert(target.isImplementation);
-    assert(target == elements.analyzedElement);
+    assert(target.declaration == resolvedAst.element);
     FunctionSignature signature = target.functionSignature;
 
     // Establish a scope in case parameters are captured.
     ClosureScope scope = getClosureScopeForFunction(target);
     irBuilder.enterScope(scope);
 
     // Load required parameters
     int index = 0;
     signature.forEachRequiredParameter((ParameterElement param) {
       irBuilder.declareLocalVariable(param, initialValue: arguments[index]);
@@ skipping 54 matching lines @@
   ///
   /// The parameters to superconstructors are, however, assumed *not* to be in
   /// the environment, but will be put there by this procedure.
   ///
   /// All constructors will be added to [supers], with superconstructors first.
   void evaluateConstructorFieldInitializers(
       ConstructorElement constructor,
       List<ConstructorElement> supers,
       Map<FieldElement, ir.Primitive> fieldValues) {
     assert(constructor.isImplementation);
-    assert(constructor == elements.analyzedElement);
+    assert(constructor.declaration == resolvedAst.element);
     ClassElement enclosingClass = constructor.enclosingClass.implementation;
     // Evaluate declaration-site field initializers, unless this constructor
     // redirects to another using a `this()` initializer. In that case, these
     // will be initialized by the effective target constructor.
     if (!constructor.isRedirectingGenerative) {
       enclosingClass.forEachInstanceField((ClassElement c, FieldElement field) {
         if (field.initializer != null) {
           fieldValues[field] = inlineExpression(field, field.initializer);
         } else {
           if (backend.isNativeOrExtendsNative(c)) {
@@ skipping 73 matching lines @@
   }
 
   /// Builds the IR for the body of a constructor.
   ///
   /// This function is invoked from one or more "factory" constructors built by
   /// [buildConstructor].
   ir.FunctionDefinition buildConstructorBody(ConstructorBodyElement body) {
     ConstructorElement constructor = body.constructor;
     ast.FunctionExpression node = constructor.node;
     closureClassMap = compiler.closureToClassMapper
-        .computeClosureToClassMapping(constructor, node, elements);
+        .computeClosureToClassMapping(constructor.resolvedAst);
 
     // We compute variables boxed in mutable variables on entry to each try
     // block, not including variables captured by a closure (which are boxed
     // in the heap).  This duplicates some of the work of closure conversion
     // without directly using the results.  This duplication is wasteful and
     // error-prone.
     // TODO(kmillikin): We should combine closure conversion and try/catch
     // variable analysis in some way.
     TryBoxedVariables variables = _analyzeTryBoxedVariables(node);
     tryStatements = variables.tryStatements;
@@ skipping 10 matching lines @@
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
 
     assert(!element.isSynthesized);
     assert(node != null);
     assert(elements[node] != null);
 
     closureClassMap = compiler.closureToClassMapper
-        .computeClosureToClassMapping(element, node, elements);
+        .computeClosureToClassMapping(element.resolvedAst);
     TryBoxedVariables variables = _analyzeTryBoxedVariables(node);
     tryStatements = variables.tryStatements;
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(
         builder, () => _makeFunctionBody(builder, element, node));
   }
 
   ir.FunctionDefinition buildStaticFieldInitializer(FieldElement element) {
     if (!backend.constants.lazyStatics.contains(element)) {
       return null; // Nothing to do.
     }
     closureClassMap = compiler.closureToClassMapper
-        .computeClosureToClassMapping(element, element.node, elements);
+        .computeClosureToClassMapping(element.resolvedAst);
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () {
       irBuilder.buildFunctionHeader(<Local>[]);
       ir.Primitive initialValue = visit(element.initializer);
       ast.VariableDefinitions node = element.node;
       ast.SendSet sendSet = node.definitions.nodes.head;
       irBuilder.buildReturn(
           value: initialValue,
           sourceInformation:
               sourceInformationBuilder.buildReturn(sendSet.assignmentOperator));
@@ skipping 3247 matching lines @@
       _backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass);
 
   String getJsInteropTargetPath(FunctionElement element) {
     return '${_backend.namer.fixedBackendPath(element)}.'
         '${_backend.nativeData.getFixedBackendName(element)}';
   }
 
   DartType get jsJavascriptObjectType =>
       _backend.helpers.jsJavaScriptObjectClass.thisType;
 }