DeclarationMirror extended with metadata.

tests/compiler/dart2js/mirrors_test.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.
 
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.dart';
 
 import 'dart:io';
 
 int count(Iterable iterable) {
@@ skipping 146 matching lines @@
                 "Constructors map is unempty");
 
   // TODO(johnniwinther): Add thorough tests of [ClassMirror.functions],
   // [ClassMirror.getters], [ClassMirror.setters], [ClassMirror.members],
   // and [ClassMirror.variable].
   Expect.isNotNull(fooClass.functions);
   Expect.isNotNull(fooClass.members);
   Expect.isNotNull(fooClass.getters);
   Expect.isNotNull(fooClass.setters);
   Expect.isNotNull(fooClass.variables);
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Metadata tests
+  //////////////////////////////////////////////////////////////////////////////
+
+  var metadata = fooClass.metadata;
+  Expect.isNotNull(metadata);
+  Expect.equals(10, metadata.length);
+
+  // @Metadata // This is intentionally the type literal.
+  var metadata0 = metadata[0];
+  Expect.isTrue(metadata0 is InstanceMirror);
+  Expect.isFalse(metadata0.hasReflectee);
+  Expect.throws(() => metadata0.reflectee, (_) => true);
+  Expect.isTrue(metadata0 is TypeInstanceMirror);
+  var metadataType = metadata0.representedType;
+  Expect.isNotNull(metadataType);
+  Expect.stringEquals('Metadata', metadataType.simpleName);
+
+  // @Metadata(null)
+  var metadata1 = metadata[1];
+  Expect.isTrue(metadata1 is InstanceMirror);
+  Expect.isFalse(metadata1.hasReflectee);
+  Expect.throws(() => metadata1.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata1.type);
+  metadata1.getField('data').then((InstanceMirror data) {
+    Expect.isNotNull(data);
+    Expect.isTrue(data.hasReflectee);
+    Expect.isNull(data.reflectee);
+  });
+
+  // @Metadata(true)
+  var metadata2 = metadata[2];
+  Expect.isTrue(metadata2 is InstanceMirror);
+  Expect.isFalse(metadata2.hasReflectee);
+  Expect.throws(() => metadata2.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata2.type);
+  metadata2.getField('data').then((InstanceMirror data) {
+    Expect.isNotNull(data);
+    Expect.isTrue(data.hasReflectee);
+    Expect.isTrue(data.reflectee);
+  });
+
+  // @Metadata(false)
+  var metadata3 = metadata[3];
+  Expect.isTrue(metadata3 is InstanceMirror);
+  Expect.isFalse(metadata3.hasReflectee);
+  Expect.throws(() => metadata3.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata3.type);
+  metadata3.getField('data').then((InstanceMirror data) {
+    Expect.isNotNull(data);
+    Expect.isTrue(data.hasReflectee);
+    Expect.isFalse(data.reflectee);
+  });
+
+  // @Metadata(0)
+  var metadata4 = metadata[4];
+  Expect.isTrue(metadata4 is InstanceMirror);
+  Expect.isFalse(metadata4.hasReflectee);
+  Expect.throws(() => metadata4.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata4.type);
+  metadata4.getField('data').then((InstanceMirror data) {
+    Expect.isNotNull(data);
+    Expect.isTrue(data.hasReflectee);
+    Expect.equals(0, data.reflectee);
+  });
+
+  // @Metadata(1.5)
+  var metadata5 = metadata[5];
+  Expect.isTrue(metadata5 is InstanceMirror);
+  Expect.isFalse(metadata5.hasReflectee);
+  Expect.throws(() => metadata5.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata5.type);
+  metadata5.getField('data').then((InstanceMirror data) {
+    Expect.isNotNull(data);
+    Expect.isTrue(data.hasReflectee);
+    Expect.equals(1.5, data.reflectee);
+  });
+
+  // @Metadata("Foo")
+  var metadata6 = metadata[6];
+  Expect.isTrue(metadata6 is InstanceMirror);
+  Expect.isFalse(metadata6.hasReflectee);
+  Expect.throws(() => metadata6.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata6.type);
+  metadata6.getField('data').then((InstanceMirror data) {
+    Expect.isNotNull(data);
+    Expect.isTrue(data.hasReflectee);
+    Expect.stringEquals("Foo", data.reflectee);
+  });
+
+  // @Metadata(const ["Foo"])
+  var metadata7 = metadata[7];
+  Expect.isTrue(metadata7 is InstanceMirror);
+  Expect.isFalse(metadata7.hasReflectee);
+  Expect.throws(() => metadata7.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata7.type);
+  metadata7.getField('data').then((InstanceMirror data) {
+    Expect.isTrue(data is ListInstanceMirror);
+    Expect.isFalse(data.hasReflectee);
+    Expect.throws(() => data.reflectee, (_) => true);
+    ListInstanceMirror listData = data;
+    Expect.equals(1, listData.length);
+    listData[0].then((InstanceMirror element) {
+      Expect.isNotNull(element);
+      Expect.isTrue(element.hasReflectee);
+      Expect.stringEquals("Foo", element.reflectee);
+    });
+  });
+
+  // @Metadata(const {'foo':"Foo"})
+  var metadata8 = metadata[8];
+  Expect.isTrue(metadata8 is InstanceMirror);
+  Expect.isFalse(metadata8.hasReflectee);
+  Expect.throws(() => metadata8.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata8.type);
+  metadata8.getField('data').then((InstanceMirror data) {
+    Expect.isTrue(data is MapInstanceMirror);
+    Expect.isFalse(data.hasReflectee);
+    Expect.throws(() => data.reflectee, (_) => true);
+    MapInstanceMirror mapData = data;
+    Expect.equals(1, mapData.length);
+    Expect.stringEquals('foo', mapData.keys.iterator().next());
+    mapData['foo'].then((InstanceMirror element) {
+      Expect.isNotNull(element);
+      Expect.isTrue(element.hasReflectee);
+      Expect.stringEquals("Foo", element.reflectee);
+    });
+    Expect.isNull(mapData['bar']);
+  });
+
+  // @metadata
+  var metadata9 = metadata[9];
+  Expect.isTrue(metadata9 is InstanceMirror);
+  Expect.isFalse(metadata9.hasReflectee);
+  Expect.throws(() => metadata9.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata9.type);
+  metadata9.getField('data').then((InstanceMirror data) {
+    Expect.isNotNull(data);
+    Expect.isTrue(data.hasReflectee);
+    Expect.isNull(data.reflectee);
+  });
 }
 
 // Testing abstract class Bar:
 //
 // abstract class Bar<E> {
 //
 // }
 void testBar(MirrorSystem system, LibraryMirror helperLibrary,
              Map<String,TypeMirror> classes) {
   var barClass = classes["Bar"];
@@ skipping 61 matching lines @@
 
   var barInterfaceMembers = barClass.members;
   Expect.isNotNull(barInterfaceMembers, "Declared members map is null");
   Expect.isTrue(barInterfaceMembers.isEmpty,
                 "Declared members map is unempty");
 
   var barInterfaceConstructors = barClass.constructors;
   Expect.isNotNull(barInterfaceConstructors, "Constructors map is null");
   Expect.isTrue(barInterfaceConstructors.isEmpty,
                 "Constructors map is unempty");
+
+  var metadata = barClass.metadata;
+  Expect.isNotNull(metadata);
+  Expect.equals(0, metadata.length);
 }
 
 // Testing class Baz:
 //
 // class Baz<E,F extends Foo> implements Bar<E> {
 //   Baz();
 //   const Baz.named();
 //   factory Baz.factory() => new Baz<E,F>();
 //
 //   static method1(e) {}
@@ skipping 459 matching lines @@
   Expect.isFalse(bazClassFactoryConstructor.isRedirectingConstructor);
   Expect.isTrue(bazClassFactoryConstructor.isFactoryConstructor);
   Expect.stringEquals('Baz.factory', bazClassFactoryConstructor.simpleName);
   Expect.stringEquals('Baz.factory', bazClassFactoryConstructor.displayName);
   Expect.stringEquals('mirrors_helper.Baz.Baz.factory',
       bazClassFactoryConstructor.qualifiedName);
   Expect.stringEquals('factory', bazClassFactoryConstructor.constructorName);
 
   // TODO(johnniwinther): Add more tests of constructors.
   // TODO(johnniwinther): Add a test for unnamed factory methods.
+
+  var metadata = bazClass.metadata;
+  Expect.isNotNull(metadata);
+  Expect.equals(0, metadata.length);
 }
 
 // class _PrivateClass {
 //   var _privateField;
 //   get _privateGetter => _privateField;
 //   void set _privateSetter(value) => _privateField = value;
 //   void _privateMethod() {}
 //   _PrivateClass._privateConstructor();
 //   factory _PrivateClass._privateFactoryConstructor() => new _PrivateClass();
 // }
@@ skipping 45 matching lines @@
   var privateFactoryConstructor =
       privateClass.members['_PrivateClass._privateFactoryConstructor'];
   Expect.isNotNull(privateFactoryConstructor);
   Expect.isTrue(privateFactoryConstructor is MethodMirror);
   Expect.isTrue(privateFactoryConstructor.isConstructor);
   Expect.isTrue(privateFactoryConstructor.isPrivate);
   Expect.isFalse(privateFactoryConstructor.isConstConstructor);
   Expect.isFalse(privateFactoryConstructor.isRedirectingConstructor);
   Expect.isFalse(privateFactoryConstructor.isGenerativeConstructor);
   Expect.isTrue(privateFactoryConstructor.isFactoryConstructor);
+
+  var metadata = privateClass.metadata;
+  Expect.isNotNull(metadata);
+  Expect.equals(0, metadata.length);
 }