DeclarationMirror extended with metadata.

tests/compiler/dart2js/mirrors_test.dart

Index: tests/compiler/dart2js/mirrors_test.dart
diff --git a/tests/compiler/dart2js/mirrors_test.dart b/tests/compiler/dart2js/mirrors_test.dart
index 8b223fa7fddf1d763e654706deb615d28a7c24e5..b24e6c8b5888128a8f14039cd348b93374455c23 100644
--- a/tests/compiler/dart2js/mirrors_test.dart
+++ b/tests/compiler/dart2js/mirrors_test.dart
@@ -163,6 +163,148 @@ void testFoo(MirrorSystem system, LibraryMirror helperLibrary,
   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
+  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 interface Bar:
@@ -243,6 +385,10 @@ void testBar(MirrorSystem system, LibraryMirror helperLibrary,
   Expect.isNotNull(barInterfaceConstructors, "Constructors map is null");
   Expect.isTrue(barInterfaceConstructors.isEmpty,
                 "Constructors map is unempty");
+
+  var metadata = barInterface.metadata;
+  Expect.isNotNull(metadata);
+  Expect.equals(0, metadata.length);
 }
 
 // Testing class Baz:
@@ -721,6 +867,10 @@ void testBaz(MirrorSystem system, LibraryMirror helperLibrary,
 
   // 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 {
@@ -785,4 +935,8 @@ void testPrivate(MirrorSystem system, LibraryMirror helperLibrary,
   Expect.isFalse(privateFactoryConstructor.isRedirectingConstructor);
   Expect.isFalse(privateFactoryConstructor.isGenerativeConstructor);
   Expect.isTrue(privateFactoryConstructor.isFactoryConstructor);
+
+  var metadata = privateClass.metadata;
+  Expect.isNotNull(metadata);
+  Expect.equals(0, metadata.length);
 }