DeclarationMirror extended with metadata.

tests/compiler/dart2js/mirrors_helper.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.
 
 /**
  * This file is read by 'mirrors_test.dart'.
  */
 
 library mirrors_helper;
 
 typedef E Func<E,F extends Foo>(F f);
 
 main() {
 
 }
 
+@Metadata
+@Metadata(null)
+@Metadata(true)
+@Metadata(false)
+@Metadata(0)
+@Metadata(1.5)
+@Metadata("Foo")
+@Metadata(const ["Foo"])
+@Metadata(const {'foo':"Foo"})
 class Foo {

[Andrei Mouravski, 2012/12/19 14:42:02]

For the sake of completeness, would you mind adding a @Metadata in front of
"class Foo {" and also I think @Metadata can be on the same line but separated
by commas.

[ahe, 2012/12/19 15:44:03]

Line breaks don't matter.  Metadata cannot be separated by commas.  The grammar
rule is:

metadata:
(‘@’ qualified (. identifier)? (arguments)?)* ;

The example could be written as:

@Metadata@Metadata(null)@Metadata(true)@Metadata(false)@Metadata(0)@Metadata(1.5)@Metadata("Foo")@Metadata(const["Foo"])@Metadata(const{'foo':"Foo"})class
Foo{}

You only need one whitespace, between "class" and "Foo".

[Andrei Mouravski, 2012/12/19 16:31:19]

Good to know.

Could you show an example of using the identifier? That just means it calls a
named constructor, right?
Is that like this?: 
@Metadata.foo("arg")

What does metadata of a compile-time constant variable look like? Is it:
@1.5

Lastly, can the class that provides the metadata ("class Metadata" here)
actually do any work? Is there any case where that class has a non compile time
use? Would a metadata class ever have methods? Or be referred to or constructed
during execution?

[ahe, 2012/12/19 18:11:23]

Actually, qualified matches Metadata.foo.  So it would have to be something
like:

@libraryPrefix.Metadata.foo("arg")
That is not legal syntax, because the rule is:

metadata:
(‘@’ qualified (. identifier)? (arguments)?)* ;

qualified:
identifier (‘.’ identifier)? ;

So @ has to be followed by an identifier.
There are only two requirements on metadata:

* It must match the grammar above,
* and it must be a compile-time constant.

A compile-time constant can have methods.  Those aren't useful in source
mirrors, but in the VM, you should be able to do something like this:

// Assume you have a ClassMirror on Foo.
ClassMirror fooClassMirror = ...;
InstanceMirror im = fooClassMirror.metadata[0];
Metadata metadata = im.reflectee;
metadata.someMethod();

 
 }
 
 interface Bar<E> {
 
 }
 
 class Baz<E,F extends Foo> implements Bar<E> {
   Baz();
   const Baz.named();
@@ skipping 18 matching lines @@
   }
 }
 
 class _PrivateClass {
   var _privateField;
   get _privateGetter => _privateField;
   void set _privateSetter(value) => _privateField = value;
   void _privateMethod() {}
   _PrivateClass._privateConstructor();
   factory _PrivateClass._privateFactoryConstructor() => new _PrivateClass();
+}
+
+class Metadata {
+  final data;
+  const Metadata(this.data);

[ahe, 2012/12/19 15:44:03]

This should be an optional argument, otherwise you should be getting a
compile-time error on @Metadata.

[Johnni Winther, 2012/12/20 11:30:35]

No. @Metadata is the type literal constant. It would be an error to have
@Metadata() though.

 }