Store and serialize NativeBehavior in TreeElements.

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 38 matching lines @@
   ENUM_INDEX_FIELD,
   ENUM_VALUES_FIELD,
   ENUM_TO_STRING,
   FACTORY,
   FIELD,
   FUNCTION,
 }
 
 /// Serializer for [ResolvedAst]s.
 class ResolvedAstSerializer extends Visitor {
+  final SerializerPlugin nativeDataSerializer;
   final ObjectEncoder objectEncoder;
   final ResolvedAst resolvedAst;
   final AstIndexComputer indexComputer = new AstIndexComputer();
   final Map<int, ObjectEncoder> nodeData = <int, ObjectEncoder>{};
   ListEncoder _nodeDataEncoder;
 
-  ResolvedAstSerializer(this.objectEncoder, this.resolvedAst);
+  ResolvedAstSerializer(
+      this.objectEncoder, this.resolvedAst, this.nativeDataSerializer);
 
   AstElement get element => resolvedAst.element;
 
   TreeElements get elements => resolvedAst.elements;
 
   Node get root => resolvedAst.node;
 
   Map<Node, int> get nodeIndices => indexComputer.nodeIndices;
   List<Node> get nodeList => indexComputer.nodeList;
 
@@ skipping 156 matching lines @@
     }
     DartType cachedType = elements.typesCache[node];
     if (cachedType != null) {
       getNodeDataEncoder(node).setType(Key.CACHED_TYPE, cachedType);
     }
     JumpTarget jumpTargetDefinition = elements.getTargetDefinition(node);
     if (jumpTargetDefinition != null) {
       getNodeDataEncoder(node).setInt(
           Key.JUMP_TARGET_DEFINITION, getJumpTargetId(jumpTargetDefinition));
     }
+    var nativeData = elements.getNativeData(node);
+    if (nativeData != null) {
+      nativeDataSerializer.onData(
+          nativeData, getNodeDataEncoder(node).createObject(Key.NATIVE));
+    }
     node.visitChildren(this);
   }
 
   @override
   visitSend(Send node) {
     visitExpression(node);
     SendStructure structure = elements.getSendStructure(node);
     if (structure != null) {
       serializeSendStructure(
           structure, getNodeDataEncoder(node).createObject(Key.SEND_STRUCTURE));
@@ skipping 46 matching lines @@
         return token;
       }
       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,
-      ParsingContext parsing, Token getBeginToken(Uri uri, int charOffset)) {
+  static ResolvedAst deserialize(
+      Element element,
+      ObjectDecoder objectDecoder,
+      ParsingContext parsing,
+      Token getBeginToken(Uri uri, int charOffset),
+      DeserializerPlugin nativeDataDeserializer) {
     ResolvedAstKind kind =
         objectDecoder.getEnum(Key.KIND, ResolvedAstKind.values);
     switch (kind) {
       case ResolvedAstKind.PARSED:
-        return deserializeParsed(
-            element, objectDecoder, parsing, getBeginToken);
+        return deserializeParsed(element, objectDecoder, parsing, getBeginToken,
+            nativeDataDeserializer);
       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,
       ParsingContext parsing,
-      Token getBeginToken(Uri uri, int charOffset)) {
+      Token getBeginToken(Uri uri, int charOffset),
+      DeserializerPlugin nativeDataDeserializer) {
     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 254 matching lines @@
         int labelDefinitionId =
             objectDecoder.getInt(Key.LABEL_DEFINITION, isOptional: true);
         if (labelDefinitionId != null) {
           elements.defineLabel(node, labelDefinitions[labelDefinitionId]);
         }
         int targetLabelId =
             objectDecoder.getInt(Key.TARGET_LABEL, isOptional: true);
         if (targetLabelId != null) {
           elements.registerTargetLabel(node, labelDefinitions[targetLabelId]);
         }
+        ObjectDecoder nativeDataDecoder =
+            objectDecoder.getObject(Key.NATIVE, isOptional: true);
+        if (nativeDataDecoder != null) {
+          var nativeData = nativeDataDeserializer.onData(nativeDataDecoder);
+          if (nativeData != null) {
+            elements.registerNativeData(node, nativeData);
+          }
+        }
       }
     }
     return new ParsedResolvedAst(element, root, body, elements);
   }
 }