Create an outline of metadata API in dart2js.

dart/lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 88 matching lines @@
   static final ElementKind VOID =
     const ElementKind('void', ElementCategory.NONE);
 
   toString() => id;
 }
 
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
-  Link<Node> metadata = const EmptyLink<Node>();
+  Link<MetadataAnnotation> metadata = const EmptyLink<MetadataAnnotation>();
 
   Element(this.name, this.kind, this.enclosingElement) {
     assert(getLibrary() !== null);
   }
 
   Modifiers get modifiers => null;
 
   Node parseNode(DiagnosticListener listener) {
     listener.cancel("Internal Error: $this.parseNode", token: position());
   }
 
   Type computeType(Compiler compiler) {
     compiler.internalError("$this.computeType.", token: position());
   }
 
-  void addMetadata(Node node) {
-    metadata = metadata.prepend(node);
+  void addMetadata(MetadataAnnotation annotation) {
+    metadata = metadata.prepend(annotation);
   }
 
   bool isFunction() => kind === ElementKind.FUNCTION;
   bool isConstructor() => isFactoryConstructor() || isGenerativeConstructor();
   bool isClosure() => false;
   bool isMember() {
     // Check that this element is defined in the scope of a Class.
     Element enclosing = enclosingElement;
     if (enclosing !== null &&
         enclosing.kind === ElementKind.COMPILATION_UNIT_OVERRIDE) {
@@ skipping 178 matching lines @@
       : super(const SourceString('erroneous element'), null, enclosing);
 
   isErroneous() => true;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
   SourceString get name => unsupported();
   ElementKind get kind => unsupported();
-  Link<Node> get metadata => unsupported();
+  Link<MetadataAnnotation> get metadata => unsupported();
 }
 
 class ErroneousFunctionElement extends ErroneousElement
                                implements FunctionElement {
   ErroneousFunctionElement(errorMessage, Element enclosing)
       : super(errorMessage, enclosing);
 
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
@@ skipping 1223 matching lines @@
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   Token position() => cachedNode.getBeginToken();
 
   TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypeVariableElement result =
         new TypeVariableElement(name, enclosing, cachedNode, type, bound);
     return result;
   }
 }
+
+/**
+ * A single metadata annotation.
+ *
+ * For example, consider:
+ *
+ * [:
+ * class Data {
+ *   const Data();
+ * }
+ *
+ * const data = const Data();
+ *
+ * @data
+ * class Foo {}
+ *
+ * @data @data
+ * class Bar {}
+ * :]
+ *
+ * In this example, there are three instances of [MetadataAnnotation]
+ * and they correspond each to a location in the source code where
+ * there is an at-sign, '@'. The [value] of each of these instances
+ * are the same compile-time constant, [: const Data() :].
+ *
+ * The mirror system does not have a concept matching this class.
+ */
+class MetadataAnnotation {
+  /**
+   * The compile-time constant which this annotation resolves to.
+   * In the mirror system, this would be an object mirror.
+   */
+  abstract Constant get value();
+
+  // TODO(ahe): Add more functionality as needed.
+}