Expand ResolvedAst to handle synthetic constructors.

pkg/compiler/lib/src/serialization/resolved_ast_serialization.dart

 // Copyright (c) 2016, 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.serialization.resolved_ast;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 55 matching lines @@
 
   TreeElements get elements => resolvedAst.elements;
 
   Node get root => resolvedAst.node;
 
   Map<Node, int> get nodeIndices => indexComputer.nodeIndices;
   List<Node> get nodeList => indexComputer.nodeList;
 
   /// Serializes [resolvedAst] into [objectEncoder].
   void serialize() {
+    objectEncoder.setEnum(Key.KIND, resolvedAst.kind);
+    switch (resolvedAst.kind) {
+      case ResolvedAstKind.PARSED:
+        serializeParsed();
+        break;
+      case ResolvedAstKind.DEFAULT_CONSTRUCTOR:
+      case ResolvedAstKind.FORWARDING_CONSTRUCTOR:
+        // No additional properties.
+        break;
+    }
+  }
+
+  /// Serialize [ResolvedAst] that is defined in terms of an AST together with
+  /// [TreeElements].
+  void serializeParsed() {
     objectEncoder.setUri(
         Key.URI,
         elements.analyzedElement.compilationUnit.script.resourceUri,
         elements.analyzedElement.compilationUnit.script.resourceUri);
     AstKind kind;
     if (element.enclosingClass is EnumClassElement) {
       if (element.name == 'index') {
         kind = AstKind.ENUM_INDEX_FIELD;
       } else if (element.name == 'values') {
         kind = AstKind.ENUM_VALUES_FIELD;
@@ skipping 17 matching lines @@
       } else {
         kind = AstKind.FUNCTION;
         FunctionExpression functionExpression = root.asFunctionExpression();
         if (functionExpression.getOrSet != null) {
           // Getters/setters need the get/set token to be parsed.
           objectEncoder.setInt(
               Key.GET_OR_SET, functionExpression.getOrSet.charOffset);
         }
       }
     }
-    objectEncoder.setEnum(Key.KIND, kind);
+    objectEncoder.setEnum(Key.SUB_KIND, kind);
     root.accept(indexComputer);
     root.accept(this);
   }
 
   /// Computes the [ListEncoder] for serializing data for nodes.
   ListEncoder get nodeDataEncoder {
     if (_nodeDataEncoder == null) {
       _nodeDataEncoder = objectEncoder.createList(Key.DATA);
     }
     return _nodeDataEncoder;
@@ skipping 85 matching lines @@
       token = token.next;
     }
     return null;
   }
 
   /// Deserializes the [ResolvedAst] for [element] from [objectDecoder].
   /// [parsing] and [getBeginToken] are used for parsing the [Node] for
   /// [element] from its source code.
   static ResolvedAst deserialize(Element element, ObjectDecoder objectDecoder,
       Parsing parsing, Token getBeginToken(Uri uri, int charOffset)) {
+    ResolvedAstKind kind =
+        objectDecoder.getEnum(Key.KIND, ResolvedAstKind.values);
+    switch (kind) {
+      case ResolvedAstKind.PARSED:
+        return deserializeParsed(
+            element, objectDecoder, parsing, getBeginToken);
+      case ResolvedAstKind.DEFAULT_CONSTRUCTOR:
+      case ResolvedAstKind.FORWARDING_CONSTRUCTOR:
+        return new SynthesizedResolvedAst(element, kind);
+    }
+  }
+
+  /// Deserialize a [ResolvedAst] that is defined in terms of an AST together
+  /// with [TreeElements].
+  static ResolvedAst deserializeParsed(
+      Element element,
+      ObjectDecoder objectDecoder,
+      Parsing parsing,
+      Token getBeginToken(Uri uri, int charOffset)) {
     CompilationUnitElement compilationUnit = element.compilationUnit;
     DiagnosticReporter reporter = parsing.reporter;
 
     /// Returns the first [Token] for parsing the [Node] for [element].
     Token readBeginToken() {
       Uri uri = objectDecoder.getUri(Key.URI);
       int charOffset = objectDecoder.getInt(Key.OFFSET);
       Token beginToken = getBeginToken(uri, charOffset);
       if (beginToken == null) {
         reporter.internalError(
@@ skipping 130 matching lines @@
                   "No token found for $element in "
                   "${objectDecoder.getUri(Key.URI)} @ $getOrSetOffset");
             }
           }
           return doParse((parser) {
             parser.parseFunction(beginToken, getOrSet);
           });
       }
     }
 
-    AstKind kind = objectDecoder.getEnum(Key.KIND, AstKind.values);
+    AstKind kind = objectDecoder.getEnum(Key.SUB_KIND, AstKind.values);
     Node root = computeNode(kind);
     TreeElementMapping elements = new TreeElementMapping(element);
     AstIndexComputer indexComputer = new AstIndexComputer();
     Map<Node, int> nodeIndices = indexComputer.nodeIndices;
     List<Node> nodeList = indexComputer.nodeList;
     root.accept(indexComputer);
     ListDecoder dataDecoder = objectDecoder.getList(Key.DATA);
     if (dataDecoder != null) {
       for (int i = 0; i < dataDecoder.length; i++) {
         ObjectDecoder objectDecoder = dataDecoder.getObject(i);
@@ skipping 30 matching lines @@
               node, deserializeSendStructure(sendStructureDecoder));
         }
         ObjectDecoder newStructureDecoder =
             objectDecoder.getObject(Key.NEW_STRUCTURE, isOptional: true);
         if (newStructureDecoder != null) {
           elements.setNewStructure(
               node, deserializeNewStructure(newStructureDecoder));
         }
       }
     }
-    return new ResolvedAst(element, root, elements);
+    return new ParsedResolvedAst(element, root, elements);
   }
 }