Support deserialized compilation of the empty program.

pkg/compiler/lib/src/elements/elements.dart

 // Copyright (c) 2012, 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 elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/constructors.dart';
@@ skipping 1181 matching lines @@
 
   const AsyncMarker._({this.isAsync: false, this.isYielding: false});
 
   String toString() {
     return '${isAsync ? 'async' : 'sync'}${isYielding ? '*' : ''}';
   }
 
   /// Canonical list of marker values.
   ///
   /// Added to make [AsyncMarker] enum-like.
-  static const List<AsyncMarker> values =
-      const <AsyncMarker>[SYNC, SYNC_STAR, ASYNC, ASYNC_STAR];
-
+  static const List<AsyncMarker> values = const <AsyncMarker>[
+    SYNC,
+    SYNC_STAR,
+    ASYNC,
+    ASYNC_STAR
+  ];
 
   /// Index to this marker within [values].
   ///
   /// Added to make [AsyncMarker] enum-like.
   int get index => values.indexOf(this);
 }
 
 /// A top level, static or instance function.
 abstract class MethodElement extends FunctionElement implements MemberElement {}
 
@@ skipping 438 matching lines @@
 }
 
 /// [ResolvedAst] contains info that define the semantics of an element.
 abstract class ResolvedAst {
   /// The element whose semantics is defined.
   Element get element;
 
   /// The kind of semantics definition used for this object.
   ResolvedAstKind get kind;
 
-  /// The AST node for [element]. This only available of [kind] is
-  /// `ResolvedAstKind.PARSED`.
+  /// The root AST node for the declaration of [element]. This only available if
+  /// [kind] is `ResolvedAstKind.PARSED`.
   Node get node;
 
+  /// The AST node for the 'body' of [element].
+  ///
+  /// For functions and constructors this is the root AST node of the method
+  /// body, and for variables this is the root AST node of the initializer, if
+  /// available.
+  ///
+  /// This only available if [kind] is `ResolvedAstKind.PARSED`.
+  Node get body;
+
   /// The [TreeElements] containing the resolution data for [node]. This only
   /// available of [kind] is `ResolvedAstKind.PARSED`.
   TreeElements get elements;
 }
 
 /// [ResolvedAst] implementation used for elements whose semantics is defined in
 /// terms an AST and a [TreeElements].
 class ParsedResolvedAst implements ResolvedAst {
   final Element element;
   final Node node;
+  final Node body;
   final TreeElements elements;
 
-  ParsedResolvedAst(this.element, this.node, this.elements);
+  ParsedResolvedAst(this.element, this.node, this.body, this.elements);
 
   ResolvedAstKind get kind => ResolvedAstKind.PARSED;
 
   String toString() => '$kind:$element:$node';
 }
 
 /// [ResolvedAst] implementation used for synthesized elements whose semantics
 /// is not defined in terms an AST and a [TreeElements].
 class SynthesizedResolvedAst implements ResolvedAst {
   final Element element;
   final ResolvedAstKind kind;
 
   SynthesizedResolvedAst(this.element, this.kind);
 
   @override
   TreeElements get elements {
     throw new UnsupportedError('$this does not provide a TreeElements');
   }
 
   @override
   Node get node {
-    throw new UnsupportedError('$this does not have an AST');
+    throw new UnsupportedError('$this does not have a root AST node');
+  }
+
+  @override
+  Node get body {
+    throw new UnsupportedError('$this does not have a body AST node');
   }
 
   String toString() => '$kind:$element';
 }
 
 /// A [MemberSignature] is a member of an interface.
 ///
 /// A signature is either a method or a getter or setter, possibly implicitly
 /// defined by a field declarations. Fields themselves are not members of an
 /// interface.
@@ skipping 64 matching lines @@
   /// by a field.
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }