Serialize metadata

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

 // Copyright (c) 2015, 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.
 
 /// Implementation of the element model used for deserialiation.
 ///
 /// These classes are created by [ElementDeserializer] triggered by the
 /// [Deserializer].
 
 library dart2js.serialization.modelz;
@@ skipping 94 matching lines @@
 
   @override
   bool get isStatic => false;
 
   @override
   bool get isSynthesized => false;
 
   @override
   bool get isTopLevel => false;
 
-  // TODO(johnniwinther): Support metadata.
   @override
   Iterable<MetadataAnnotation> get metadata => const <MetadataAnnotation>[];
 
   @override
   Token get position => _unsupported('position');
 }
 
 abstract class DeserializedElementZ extends ElementZ {
   ObjectDecoder _decoder;
+  List<MetadataAnnotation> _metadata;
 
   DeserializedElementZ(this._decoder);
 
   @override
   String get name => _decoder.getString(Key.NAME);
 
   // TODO(johnniwinther): Should this be cached?
   @override
   int get sourceOffset => _decoder.getInt(Key.OFFSET, isOptional: true);
 
   @override
   SourceSpan get sourcePosition {
     // TODO(johnniwinther): Should this be cached?
     int offset = sourceOffset;
     if (offset == null) return null;
     Uri uri = _decoder.getUri(Key.URI, isOptional: true);
     if (uri == null) {
       uri = compilationUnit.script.readableUri;
     }
     int length = _decoder.getInt(Key.LENGTH, isOptional: true);
     if (length == null) {
       length = name.length;
     }
     return new SourceSpan(uri, offset, offset + length);
   }
+
+  @override
+  Iterable<MetadataAnnotation> get metadata {
+    if (_metadata == null) {
+      _metadata = <MetadataAnnotation>[];
+      ListDecoder list = _decoder.getList(Key.METADATA, isOptional: true);
+      if (list != null) {
+        for (int index = 0; index < list.length; index++) {
+          ObjectDecoder object = list.getObject(index);
+          Element element = object.getElement(Key.ELEMENT);
+          Uri uri = object.getUri(Key.URI);
+          int offset = object.getInt(Key.OFFSET);
+          int length = object.getInt(Key.LENGTH);
+          ConstantExpression constant = object.getConstant(Key.CONSTANT);
+          _metadata.add(new MetadataAnnotationZ(
+              element, new SourceSpan(uri, offset, offset + length), constant));
+        }
+      }
+    }
+    return _metadata;
+  }
 }
 
 /// Deserializer for a collection of member elements serialized as a map from
 /// names to element declarations.
 ///
 /// The serialized data contains the declared getters and setters but lookup
 /// into the map returns an [AbstractFieldElement] for pairs of corresponding
 /// getters and setters.
 ///
 /// The underlying map encoding allows for lazy computation of the members upon
@@ skipping 779 matching lines @@
   @override
   Link<DartType> get interfaces {
     _ensureSuperHierarchy();
     return _interfaces;
   }
 
   @override
   bool get isProxy => _decoder.getBool(Key.IS_PROXY);
 
   @override
+  bool get isInjected => _decoder.getBool(Key.IS_INJECTED);
+
+  @override
   bool get isUnnamedMixinApplication => false;
 
   @override
   FunctionType get callType {
     _ensureSuperHierarchy();
     // TODO(johnniwinther): Why can't this always be computed in ensureResolved?
     return _callType;
   }
 }
 
@@ skipping 514 matching lines @@
 abstract class MemberElementMixin
     implements DeserializedElementZ, MemberElement {
   @override
   MemberElement get memberContext => this;
 
   @override
   Name get memberName => new Name(name, library);
 
   @override
   List<FunctionElement> get nestedClosures => <FunctionElement>[];
+
+  @override
+  bool get isInjected => _decoder.getBool(Key.IS_INJECTED);
 }
 
 abstract class FieldElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
         AstElementMixinZ,
         TypedElementMixin,
         MemberElementMixin
     implements FieldElement {
   bool _isConst;
@@ skipping 763 matching lines @@
   }
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 
   @override
   Element lookupLocalMember(String memberName) {
     return _unsupported('lookupLocalMember');
   }
 }
+
+class MetadataAnnotationZ implements MetadataAnnotation {
+  final Element annotatedElement;
+  final SourceSpan sourcePosition;
+  final ConstantExpression constant;
+
+  MetadataAnnotationZ(
+      this.annotatedElement, this.sourcePosition, this.constant);
+
+  @override
+  MetadataAnnotation ensureResolved(Resolution resolution) {
+    // Do nothing.
+  }
+
+  @override
+  Node get node => throw new UnsupportedError('${this}.node');
+
+  @override
+  bool get hasNode => false;
+
+  String toString() => 'MetadataAnnotationZ(${constant.toDartText()})';
+}