Evaluate compile-time constants of metadata.

dart/lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 135 matching lines @@
                                         FunctionExpression node) {
     if (constructor.defaultImplementation !== constructor) return;
     ClassElement intrface = constructor.getEnclosingClass();
     if (!intrface.isInterface()) return;
     Type defaultType = intrface.defaultClass;
     if (defaultType === null) {
       error(node, MessageKind.NO_DEFAULT_CLASS, [intrface.name]);
     }
     ClassElement defaultClass = defaultType.element;
     defaultClass.ensureResolved(compiler);
-    assert(defaultClass.resolutionState == ClassElement.STATE_DONE);
-    assert(defaultClass.supertypeLoadState == ClassElement.STATE_DONE);
+    assert(defaultClass.resolutionState == STATE_DONE);
+    assert(defaultClass.supertypeLoadState == STATE_DONE);
     if (defaultClass.isInterface()) {
       error(node, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
             [defaultClass.name]);
     }
     // We have now established the following:
     // [intrface] is an interface, let's say "MyInterface".
     // [defaultClass] is a class, let's say "MyClass".
 
     // If the default class implements the interface then we must use the
     // default class' name. Otherwise we look for a factory with the name
@@ skipping 45 matching lines @@
   }
 
   /**
    * Load and resolve the supertypes of [cls].
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
    */
   void loadSupertypes(ClassElement cls, Node from) {
     compiler.withCurrentElement(cls, () => measure(() {
-      if (cls.supertypeLoadState == ClassElement.STATE_DONE) return;
-      if (cls.supertypeLoadState == ClassElement.STATE_STARTED) {
+      if (cls.supertypeLoadState == STATE_DONE) return;
+      if (cls.supertypeLoadState == STATE_STARTED) {
         compiler.reportMessage(
           compiler.spanFromNode(from),
           MessageKind.CYCLIC_CLASS_HIERARCHY.error([cls.name]),
           api.Diagnostic.ERROR);
-        cls.supertypeLoadState = ClassElement.STATE_DONE;
+        cls.supertypeLoadState = STATE_DONE;
         cls.allSupertypes = const EmptyLink<Type>().prepend(
             compiler.objectClass.computeType(compiler));
         // TODO(ahe): We should also set cls.supertype here to avoid
         // creating a malformed class hierarchy.
         return;
       }
-      cls.supertypeLoadState = ClassElement.STATE_STARTED;
+      cls.supertypeLoadState = STATE_STARTED;
       compiler.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
         cls.parseNode(compiler).accept(new ClassSupertypeResolver(compiler,
                                                                   cls));
-        if (cls.supertypeLoadState != ClassElement.STATE_DONE) {
-          cls.supertypeLoadState = ClassElement.STATE_DONE;
+        if (cls.supertypeLoadState != STATE_DONE) {
+          cls.supertypeLoadState = STATE_DONE;
         }
       });
     }));
   }
 
   /**
    * Resolve the class [element].
    *
    * Before calling this method, [element] was constructed by the
    * scanner and most fields are null or empty. This method fills in
    * these fields and also ensure that the supertypes of [element] are
    * resolved.
    *
    * Warning: Do not call this method directly. Instead use
    * [:element.ensureResolved(compiler):].
    */
   void resolveClass(ClassElement element) {
-    assert(element.resolutionState == ClassElement.STATE_NOT_STARTED);
-    element.resolutionState = ClassElement.STATE_STARTED;
     compiler.withCurrentElement(element, () => measure(() {
+      assert(element.resolutionState == STATE_NOT_STARTED);
+      element.resolutionState = STATE_STARTED;
       ClassNode tree = element.parseNode(compiler);
       loadSupertypes(element, tree);
 
       ClassResolverVisitor visitor =
         new ClassResolverVisitor(compiler, element);
       visitor.visit(tree);
-      element.resolutionState = ClassElement.STATE_DONE;
+      element.resolutionState = STATE_DONE;
     }));
   }
 
   void checkMembers(ClassElement cls) {
     if (cls === compiler.objectClass) return;
     cls.forEachMember((holder, member) {
       checkAbstractField(member);
       checkValidOverride(member, cls.lookupSuperMember(member.name));
     });
   }
@@ skipping 128 matching lines @@
          !link.isEmpty();
          link = link.tail) {
        parameterTypes.addLast(link.head.computeType(compiler));
        // TODO(karlklose): optional parameters.
     }
     return new FunctionType(signature.returnType,
                             parameterTypes.toLink(),
                             element);
   }
 
+  void resolveMetadataAnnotation(MetadataAnnotation annotation) {
+    compiler.withCurrentElement(annotation.annotatedElement, () => measure(() {
+      assert(annotation.resolutionState == STATE_NOT_STARTED);
+      annotation.resolutionState = STATE_STARTED;
+
+      Node node = annotation.parseNode(compiler);
+      ResolverVisitor visitor =
+          new ResolverVisitor(compiler, annotation.annotatedElement);
+      node.accept(visitor);
+      annotation.value = compiler.constantHandler.compileNodeWithDefinitions(
+          node, visitor.mapping);
+
+      annotation.resolutionState = STATE_DONE;
+    }));
+  }
+
   error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError message = new ResolutionError(kind, arguments);
     compiler.reportError(node, message);
   }
 }
 
 class InitializerResolver {
   final ResolverVisitor visitor;
   final Map<SourceString, Node> initialized;
   Link<Node> initializers;
@@ skipping 70 matching lines @@
     return result;
   }
 
   void resolveImplicitSuperConstructorSend(FunctionElement constructor,
                                            FunctionExpression functionNode) {
     // If the class has a super resolve the implicit super call.
     ClassElement classElement = constructor.getEnclosingClass();
     ClassElement superClass = classElement.superclass;
     if (classElement != visitor.compiler.objectClass) {
       assert(superClass !== null);
-      assert(superClass.resolutionState == ClassElement.STATE_DONE);
+      assert(superClass.resolutionState == STATE_DONE);
       SourceString name = const SourceString('');
       Selector call = new Selector.call(name, classElement.getLibrary(), 0);
       var element = resolveSuperOrThis(constructor, true, true,
                                        name, call, functionNode);
       visitor.world.registerStaticUse(element);
     }
   }
 
   Element resolveSuperOrThis(FunctionElement constructor,
                              bool isSuperCall,
@@ skipping 1350 matching lines @@
  * types.
  */
 class ClassResolverVisitor extends TypeDefinitionVisitor {
   ClassElement get element => super.element;
 
   ClassResolverVisitor(Compiler compiler, ClassElement classElement)
     : super(compiler, classElement);
 
   Type visitClassNode(ClassNode node) {
     compiler.ensure(element !== null);
-    compiler.ensure(element.resolutionState == ClassElement.STATE_STARTED);
+    compiler.ensure(element.resolutionState == STATE_STARTED);
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     // TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
     // As a side-effect, this may get us back here trying to
     // resolve this class again.
     resolveTypeVariableBounds(node.typeParameters);
 
     // Find super type.
     Type supertype = visit(node.superclass);
@@ skipping 652 matching lines @@
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }