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 175 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 500 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;
 }