Report info messages together with their error, warning, or hint.

pkg/compiler/lib/src/resolution/resolution.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 dart2js.resolution;
 
 import 'dart:collection' show Queue;
 
 import '../common/names.dart' show
     Identifiers;
 import '../common/tasks.dart' show
     CompilerTask,
     DeferredAction;
 import '../compiler.dart' show
     Compiler;
 import '../compile_time_constants.dart' show
     ConstantCompiler;
 import '../constants/values.dart' show
     ConstantValue;
 import '../dart_types.dart';
+import '../diagnostics/diagnostic_listener.dart' show
+    DiagnosticMessage;
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/messages.dart' show
     MessageKind;
 import '../diagnostics/spannable.dart' show
     Spannable;
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
     BaseClassElementX,
     BaseFunctionElementX,
@@ skipping 83 matching lines @@
                                      FunctionElement redirection) {
     assert(invariant(node, constructor.isImplementation,
         message: 'Redirecting constructors must be resolved on implementation '
                  'elements.'));
     Setlet<FunctionElement> seen = new Setlet<FunctionElement>();
     seen.add(constructor);
     while (redirection != null) {
       // Ensure that we follow redirections through implementation elements.
       redirection = redirection.implementation;
       if (seen.contains(redirection)) {
-        resolver.visitor.error(node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
+        compiler.reportErrorMessage(
+            node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
         return;
       }
       seen.add(redirection);
       redirection = resolver.visitor.resolveConstructorRedirection(redirection);
     }
   }
 
   static void processAsyncMarker(Compiler compiler,
                                  BaseFunctionElementX element,
                                  ResolutionRegistry registry) {
     FunctionExpression functionExpression = element.node;
     AsyncModifier asyncModifier = functionExpression.asyncModifier;
     if (asyncModifier != null) {
 
       if (asyncModifier.isAsynchronous) {
         element.asyncMarker = asyncModifier.isYielding
             ? AsyncMarker.ASYNC_STAR : AsyncMarker.ASYNC;
       } else {
         element.asyncMarker = AsyncMarker.SYNC_STAR;
       }
       if (element.isAbstract) {
-        compiler.reportError(asyncModifier,
+        compiler.reportErrorMessage(
+            asyncModifier,
             MessageKind.ASYNC_MODIFIER_ON_ABSTRACT_METHOD,
             {'modifier': element.asyncMarker});
       } else if (element.isConstructor) {
-        compiler.reportError(asyncModifier,
+        compiler.reportErrorMessage(
+            asyncModifier,
             MessageKind.ASYNC_MODIFIER_ON_CONSTRUCTOR,
             {'modifier': element.asyncMarker});
       } else {
         if (element.isSetter) {
-          compiler.reportError(asyncModifier,
+          compiler.reportErrorMessage(
+              asyncModifier,
               MessageKind.ASYNC_MODIFIER_ON_SETTER,
               {'modifier': element.asyncMarker});
 
         }
         if (functionExpression.body.asReturn() != null &&
             element.asyncMarker.isYielding) {
-          compiler.reportError(asyncModifier,
+          compiler.reportErrorMessage(
+              asyncModifier,
               MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY,
               {'modifier': element.asyncMarker});
         }
       }
       registry.registerAsyncMarker(element);
       switch (element.asyncMarker) {
       case AsyncMarker.ASYNC:
         compiler.futureClass.ensureResolved(compiler);
         break;
       case AsyncMarker.ASYNC_STAR:
@@ skipping 12 matching lines @@
       if (classElement.isNative) return true;
       classElement = classElement.superclass;
     }
     return false;
   }
 
   WorldImpact resolveMethodElementImplementation(
       FunctionElement element, FunctionExpression tree) {
     return compiler.withCurrentElement(element, () {
       if (element.isExternal && tree.hasBody()) {
-        error(element,
+        compiler.reportErrorMessage(
+            element,
             MessageKind.EXTERNAL_WITH_BODY,
             {'functionName': element.name});
       }
       if (element.isConstructor) {
         if (tree.returnType != null) {
-          error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
+          compiler.reportErrorMessage(
+              tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
         }
         if (element.isConst &&
             tree.hasBody() &&
             !tree.isRedirectingFactory) {
-          error(tree, MessageKind.CONST_CONSTRUCTOR_HAS_BODY);
+          compiler.reportErrorMessage(
+              tree, MessageKind.CONST_CONSTRUCTOR_HAS_BODY);
         }
       }
 
       ResolverVisitor visitor = visitorFor(element);
       ResolutionRegistry registry = visitor.registry;
       registry.defineFunction(tree, element);
       visitor.setupFunction(tree, element);
       processAsyncMarker(compiler, element, registry);
 
       if (element.isGenerativeConstructor) {
         // Even if there is no initializer list we still have to do the
         // resolution in case there is an implicit super constructor call.
         InitializerResolver resolver =
             new InitializerResolver(visitor, element, tree);
         FunctionElement redirection = resolver.resolveInitializers();
         if (redirection != null) {
           resolveRedirectingConstructor(resolver, tree, element, redirection);
         }
       } else if (tree.initializers != null) {
-        error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
+        compiler.reportErrorMessage(
+            tree, MessageKind.FUNCTION_WITH_INITIALIZER);
       }
 
       if (!compiler.analyzeSignaturesOnly || tree.isRedirectingFactory) {
         // We need to analyze the redirecting factory bodies to ensure that
         // we can analyze compile-time constants.
         visitor.visit(tree.body);
       }
 
       // Get the resolution tree and check that the resolved
       // function doesn't use 'super' if it is mixed into another
       // class. This is the part of the 'super' mixin check that
       // happens when a function is resolved after the mixin
       // application has been performed.
       TreeElements resolutionTree = registry.mapping;
       ClassElement enclosingClass = element.enclosingClass;
       if (enclosingClass != null) {
         // TODO(johnniwinther): Find another way to obtain mixin uses.
         Iterable<MixinApplicationElement> mixinUses =
             compiler.world.allMixinUsesOf(enclosingClass);
         ClassElement mixin = enclosingClass;
         for (MixinApplicationElement mixinApplication in mixinUses) {
           checkMixinSuperUses(resolutionTree, mixinApplication, mixin);
         }
       }
 
       // TODO(9631): support noSuchMethod on native classes.
       if (Elements.isInstanceMethod(element) &&
           element.name == Identifiers.noSuchMethod_ &&
           _isNativeClassOrExtendsNativeClass(enclosingClass)) {
-        error(tree, MessageKind.NO_SUCH_METHOD_IN_NATIVE);
+        compiler.reportErrorMessage(
+            tree, MessageKind.NO_SUCH_METHOD_IN_NATIVE);
       }
 
       return registry.worldImpact;
     });
 
   }
 
   WorldImpact resolveMethodElement(FunctionElementX element) {
     assert(invariant(element, element.isDeclaration));
     return compiler.withCurrentElement(element, () {
@@ skipping 46 matching lines @@
   /// this library).
   ResolverVisitor visitorFor(Element element, {bool useEnclosingScope: false}) {
     return new ResolverVisitor(compiler, element,
         new ResolutionRegistry(compiler, _ensureTreeElements(element)),
         useEnclosingScope: useEnclosingScope);
   }
 
   WorldImpact resolveField(FieldElementX element) {
     VariableDefinitions tree = element.parseNode(compiler);
     if(element.modifiers.isStatic && element.isTopLevel) {
-      error(element.modifiers.getStatic(),
-            MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
+      compiler.reportErrorMessage(
+          element.modifiers.getStatic(),
+          MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
     ResolutionRegistry registry = visitor.registry;
     // TODO(johnniwinther): Maybe remove this when placeholderCollector migrates
     // to the backend ast.
     registry.defineElement(tree.definitions.nodes.head, element);
     // TODO(johnniwinther): Share the resolved type between all variables
     // declared in the same declaration.
     if (tree.type != null) {
       element.variables.type = visitor.resolveTypeAnnotation(tree.type);
     } else {
       element.variables.type = const DynamicType();
     }
 
     Expression initializer = element.initializer;
     Modifiers modifiers = element.modifiers;
     if (initializer != null) {
       // TODO(johnniwinther): Avoid analyzing initializers if
       // [Compiler.analyzeSignaturesOnly] is set.
       visitor.visit(initializer);
     } else if (modifiers.isConst) {
-      compiler.reportError(element, MessageKind.CONST_WITHOUT_INITIALIZER);
+      compiler.reportErrorMessage(
+          element, MessageKind.CONST_WITHOUT_INITIALIZER);
     } else if (modifiers.isFinal && !element.isInstanceMember) {
-      compiler.reportError(element, MessageKind.FINAL_WITHOUT_INITIALIZER);
+      compiler.reportErrorMessage(
+          element, MessageKind.FINAL_WITHOUT_INITIALIZER);
     } else {
       registry.registerInstantiatedClass(compiler.nullClass);
     }
 
     if (Elements.isStaticOrTopLevelField(element)) {
       visitor.addDeferredAction(element, () {
         if (element.modifiers.isConst) {
           element.constant = constantCompiler.compileConstant(element);
         } else {
           constantCompiler.compileVariable(element);
@@ skipping 10 matching lines @@
 
     // Perform various checks as side effect of "computing" the type.
     element.computeType(compiler);
 
     return registry.worldImpact;
   }
 
   DartType resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
     DartType type = resolveReturnType(element, annotation);
     if (type.isVoid) {
-      error(annotation, MessageKind.VOID_NOT_ALLOWED);
+      compiler.reportErrorMessage(
+          annotation, MessageKind.VOID_NOT_ALLOWED);
     }
     return type;
   }
 
   DartType resolveReturnType(Element element, TypeAnnotation annotation) {
     if (annotation == null) return const DynamicType();
     DartType result = visitorFor(element).resolveTypeAnnotation(annotation);
     if (result == null) {
       // TODO(karklose): warning.
       return const DynamicType();
@@ skipping 13 matching lines @@
         targetType = target.effectiveTargetType;
         assert(invariant(target, targetType != null,
             message: 'Redirection target type has not been computed for '
                      '$target'));
         target = target.internalEffectiveTarget;
         break;
       }
 
       Element nextTarget = target.immediateRedirectionTarget;
       if (seen.contains(nextTarget)) {
-        error(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
+        compiler.reportErrorMessage(
+            node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
         targetType = target.enclosingClass.thisType;
         break;
       }
       seen.add(target);
       target = nextTarget;
     }
 
     if (targetType == null) {
       assert(!target.isRedirectingFactory);
       targetType = target.enclosingClass.thisType;
@@ skipping 28 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(BaseClassElementX cls, Spannable from) {
     compiler.withCurrentElement(cls, () => measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
-        compiler.reportError(from, MessageKind.CYCLIC_CLASS_HIERARCHY,
-                                 {'className': cls.name});
+        compiler.reportErrorMessage(
+            from,
+            MessageKind.CYCLIC_CLASS_HIERARCHY,
+            {'className': cls.name});
         cls.supertypeLoadState = STATE_DONE;
         cls.hasIncompleteHierarchy = true;
         cls.allSupertypesAndSelf =
             compiler.objectClass.allSupertypesAndSelf.extendClass(
                 cls.computeType(compiler));
         cls.supertype = cls.allSupertypes.head;
         assert(invariant(from, cls.supertype != null,
             message: 'Missing supertype on cyclic class $cls.'));
         cls.interfaces = const Link<DartType>();
         return;
@@ skipping 162 matching lines @@
     } else {
       checkClassMembers(element);
     }
   }
 
   void checkMixinApplication(MixinApplicationElementX mixinApplication) {
     Modifiers modifiers = mixinApplication.modifiers;
     int illegalFlags = modifiers.flags & ~Modifiers.FLAG_ABSTRACT;
     if (illegalFlags != 0) {
       Modifiers illegalModifiers = new Modifiers.withFlags(null, illegalFlags);
-      compiler.reportError(
+      compiler.reportErrorMessage(
           modifiers,
           MessageKind.ILLEGAL_MIXIN_APPLICATION_MODIFIERS,
           {'modifiers': illegalModifiers});
     }
 
     // In case of cyclic mixin applications, the mixin chain will have
     // been cut. If so, we have already reported the error to the
     // user so we just return from here.
     ClassElement mixin = mixinApplication.mixin;
     if (mixin == null) return;
 
     // Check that we're not trying to use Object as a mixin.
     if (mixin.superclass == null) {
-      compiler.reportError(mixinApplication,
-                               MessageKind.ILLEGAL_MIXIN_OBJECT);
+      compiler.reportErrorMessage(
+          mixinApplication,
+          MessageKind.ILLEGAL_MIXIN_OBJECT);
       // Avoid reporting additional errors for the Object class.
       return;
     }
 
     if (mixin.isEnumClass) {
       // Mixing in an enum has already caused a compile-time error.
       return;
     }
 
     // Check that the mixed in class has Object as its superclass.
     if (!mixin.superclass.isObject) {
-      compiler.reportError(mixin, MessageKind.ILLEGAL_MIXIN_SUPERCLASS);
+      compiler.reportErrorMessage(
+          mixin, MessageKind.ILLEGAL_MIXIN_SUPERCLASS);
     }
 
     // Check that the mixed in class doesn't have any constructors and
     // make sure we aren't mixing in methods that use 'super'.
     mixin.forEachLocalMember((AstElement member) {
       if (member.isGenerativeConstructor && !member.isSynthesized) {
-        compiler.reportError(member, MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR);
+        compiler.reportErrorMessage(
+            member, MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR);
       } else {
         // Get the resolution tree and check that the resolved member
         // doesn't use 'super'. This is the part of the 'super' mixin
         // check that happens when a function is resolved before the
         // mixin application has been performed.
         // TODO(johnniwinther): Obtain the [TreeElements] for [member]
         // differently.
         if (compiler.enqueuer.resolution.hasBeenResolved(member)) {
           checkMixinSuperUses(
               member.resolvedAst.elements,
               mixinApplication,
               mixin);
         }
       }
     });
   }
 
   void checkMixinSuperUses(TreeElements resolutionTree,
                            MixinApplicationElement mixinApplication,
                            ClassElement mixin) {
     // TODO(johnniwinther): Avoid the use of [TreeElements] here.
     if (resolutionTree == null) return;
     Iterable<Node> superUses = resolutionTree.superUses;
     if (superUses.isEmpty) return;
-    compiler.reportError(mixinApplication,
-                         MessageKind.ILLEGAL_MIXIN_WITH_SUPER,
-                         {'className': mixin.name});
+    DiagnosticMessage error = compiler.createMessage(
+        mixinApplication,
+        MessageKind.ILLEGAL_MIXIN_WITH_SUPER,
+        {'className': mixin.name});
     // Show the user the problematic uses of 'super' in the mixin.
+    List<DiagnosticMessage> infos = <DiagnosticMessage>[];
     for (Node use in superUses) {
-      compiler.reportInfo(
+      infos.add(compiler.createMessage(
           use,
-          MessageKind.ILLEGAL_MIXIN_SUPER_USE);
+          MessageKind.ILLEGAL_MIXIN_SUPER_USE));
     }
+    compiler.reportError(error, infos);
   }
 
   void checkClassMembers(ClassElement cls) {
     assert(invariant(cls, cls.isDeclaration));
     if (cls.isObject) return;
     // TODO(johnniwinther): Should this be done on the implementation element as
     // well?
     List<Element> constConstructors = <Element>[];
     List<Element> nonFinalInstanceFields = <Element>[];
     cls.forEachMember((holder, member) {
       compiler.withCurrentElement(member, () {
         // Perform various checks as side effect of "computing" the type.
         member.computeType(compiler);
 
         // Check modifiers.
         if (member.isFunction && member.modifiers.isFinal) {
-          compiler.reportError(
+          compiler.reportErrorMessage(
               member, MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER);
         }
         if (member.isConstructor) {
           final mismatchedFlagsBits =
               member.modifiers.flags &
               (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
           if (mismatchedFlagsBits != 0) {
             final mismatchedFlags =
                 new Modifiers.withFlags(null, mismatchedFlagsBits);
-            compiler.reportError(
+            compiler.reportErrorMessage(
                 member,
                 MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS,
                 {'modifiers': mismatchedFlags});
           }
           if (member.modifiers.isConst) {
             constConstructors.add(member);
           }
         }
         if (member.isField) {
           if (member.modifiers.isConst && !member.modifiers.isStatic) {
-            compiler.reportError(
+            compiler.reportErrorMessage(
                 member, MessageKind.ILLEGAL_CONST_FIELD_MODIFIER);
           }
           if (!member.modifiers.isStatic && !member.modifiers.isFinal) {
             nonFinalInstanceFields.add(member);
           }
         }
         checkAbstractField(member);
         checkUserDefinableOperator(member);
       });
     });
     if (!constConstructors.isEmpty && !nonFinalInstanceFields.isEmpty) {
       Spannable span = constConstructors.length > 1
           ? cls : constConstructors[0];
-      compiler.reportError(span,
+      DiagnosticMessage error = compiler.createMessage(
+          span,
           MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS,
           {'className': cls.name});
+      List<DiagnosticMessage> infos = <DiagnosticMessage>[];
       if (constConstructors.length > 1) {
         for (Element constructor in constConstructors) {
-          compiler.reportInfo(constructor,
-              MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR);
+          infos.add(compiler.createMessage(
+              constructor,
+              MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR));
         }
       }
       for (Element field in nonFinalInstanceFields) {
-        compiler.reportInfo(field,
-            MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD);
+        infos.add(compiler.createMessage(
+            field,
+            MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD));
       }
+      compiler.reportError(error, infos);
     }
   }
 
   void checkAbstractField(Element member) {
     // Only check for getters. The test can only fail if there is both a setter
     // and a getter with the same name, and we only need to check each abstract
     // field once, so we just ignore setters.
     if (!member.isGetter) return;
 
     // Find the associated abstract field.
@@ skipping 11 matching lines @@
 
     GetterElementX getter = field.getter;
     if (getter == null) return;
     SetterElementX setter = field.setter;
     if (setter == null) return;
     int getterFlags = getter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     int setterFlags = setter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     if (!identical(getterFlags, setterFlags)) {
       final mismatchedFlags =
         new Modifiers.withFlags(null, getterFlags ^ setterFlags);
-      compiler.reportError(
+      compiler.reportErrorMessage(
           field.getter,
           MessageKind.GETTER_MISMATCH,
           {'modifiers': mismatchedFlags});
-      compiler.reportError(
+      compiler.reportErrorMessage(
           field.setter,
           MessageKind.SETTER_MISMATCH,
           {'modifiers': mismatchedFlags});
     }
   }
 
   void checkUserDefinableOperator(Element member) {
     FunctionElement function = member.asFunctionElement();
     if (function == null) return;
     String value = member.name;
@@ skipping 27 matching lines @@
     }
     checkArity(function, requiredParameterCount, messageKind, isMinus);
   }
 
   void checkOverrideHashCode(FunctionElement operatorEquals) {
     if (operatorEquals.isAbstract) return;
     ClassElement cls = operatorEquals.enclosingClass;
     Element hashCodeImplementation =
         cls.lookupLocalMember('hashCode');
     if (hashCodeImplementation != null) return;
-    compiler.reportHint(
+    compiler.reportHintMessage(
         operatorEquals, MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
         {'class': cls.name});
   }
 
   void checkArity(FunctionElement function,
                   int requiredParameterCount, MessageKind messageKind,
                   bool isMinus) {
     FunctionExpression node = function.node;
     FunctionSignature signature = function.functionSignature;
     if (signature.requiredParameterCount != requiredParameterCount) {
@@ skipping 20 matching lines @@
           //     int operator -(a, b) {}
           //                       ^
           //
           // since the correction might not be to remove 'b' but instead to
           // remove 'a, b'.
           errorNode = node.parameters;
         } else {
           errorNode = node.parameters.nodes.skip(requiredParameterCount).head;
         }
       }
-      compiler.reportError(
+      compiler.reportErrorMessage(
           errorNode, messageKind, {'operatorName': function.name});
     }
     if (signature.optionalParameterCount != 0) {
       Node errorNode =
           node.parameters.nodes.skip(signature.requiredParameterCount).head;
       if (signature.optionalParametersAreNamed) {
-        compiler.reportError(
+        compiler.reportErrorMessage(
             errorNode,
             MessageKind.OPERATOR_NAMED_PARAMETERS,
             {'operatorName': function.name});
       } else {
-        compiler.reportError(
+        compiler.reportErrorMessage(
             errorNode,
             MessageKind.OPERATOR_OPTIONAL_PARAMETERS,
             {'operatorName': function.name});
       }
     }
   }
 
   reportErrorWithContext(Element errorneousElement,
                          MessageKind errorMessage,
                          Element contextElement,
                          MessageKind contextMessage) {
     compiler.reportError(
-        errorneousElement,
-        errorMessage,
-        {'memberName': contextElement.name,
-         'className': contextElement.enclosingClass.name});
-    compiler.reportInfo(contextElement, contextMessage);
+        compiler.createMessage(
+            errorneousElement,
+            errorMessage,
+            {'memberName': contextElement.name,
+             'className': contextElement.enclosingClass.name}),
+        <DiagnosticMessage>[
+            compiler.createMessage(contextElement, contextMessage),
+        ]);
   }
 
 
   FunctionSignature resolveSignature(FunctionElementX element) {
     MessageKind defaultValuesError = null;
     if (element.isFactoryConstructor) {
       FunctionExpression body = element.parseNode(compiler);
       if (body.isRedirectingFactory) {
         defaultValuesError = MessageKind.REDIRECTING_FACTORY_WITH_DEFAULT;
       }
@@ skipping 57 matching lines @@
       constantCompiler.evaluate(annotation.constant);
       // TODO(johnniwinther): Register the relation between the annotation
       // and the annotated element instead. This will allow the backend to
       // retrieve the backend constant and only register metadata on the
       // elements for which it is needed. (Issue 17732).
       registry.registerMetadataConstant(annotation, annotatedElement);
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
-  error(Spannable node, MessageKind kind, [arguments = const {}]) {
-    compiler.reportError(node, kind, arguments);
-  }
-
   List<MetadataAnnotation> resolveMetadata(Element element,
                                            VariableDefinitions node) {
     List<MetadataAnnotation> metadata = <MetadataAnnotation>[];
     for (Metadata annotation in node.metadata.nodes) {
       ParameterMetadataAnnotation metadataAnnotation =
           new ParameterMetadataAnnotation(annotation);
       metadataAnnotation.annotatedElement = element;
       metadata.add(metadataAnnotation.ensureResolved(compiler));
     }
     return metadata;
@@ skipping 15 matching lines @@
   TreeElements get treeElements {
     assert(invariant(this, _treeElements !=null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }