Clean up leg.dart.

dart/lib/compiler/implementation/resolution/members.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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 377 matching lines @@
    * 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 == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
         compiler.reportMessage(
           compiler.spanFromNode(from),
           MessageKind.CYCLIC_CLASS_HIERARCHY.error([cls.name]),
-          api.Diagnostic.ERROR);
+          Diagnostic.ERROR);
         cls.supertypeLoadState = STATE_DONE;
         cls.allSupertypes = const Link<DartType>().prepend(
             compiler.objectClass.computeType(compiler));
         // TODO(ahe): We should also set cls.supertype here to avoid
         // creating a malformed class hierarchy.
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       compiler.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
@@ skipping 61 matching lines @@
     // well?
     cls.forEachMember((holder, member) {
       // Perform various checks as side effect of "computing" the type.
       member.computeType(compiler);
 
       // Check modifiers.
       if (member.isFunction() && member.modifiers.isFinal()) {
         compiler.reportMessage(
           compiler.spanFromElement(member),
           MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER.error(),
-          api.Diagnostic.ERROR);
+          Diagnostic.ERROR);
       }
       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.reportMessage(
             compiler.spanFromElement(member),
             MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS.error([mismatchedFlags]),
-            api.Diagnostic.ERROR);
+            Diagnostic.ERROR);
         }
       }
       checkAbstractField(member);
       checkValidOverride(member, cls.lookupSuperMember(member.name));
     });
   }
 
   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
@@ skipping 15 matching lines @@
     if (field.getter == null) return;
     if (field.setter == null) return;
     int getterFlags = field.getter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     int setterFlags = field.setter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     if (!identical(getterFlags, setterFlags)) {
       final mismatchedFlags =
         new Modifiers.withFlags(null, getterFlags ^ setterFlags);
       compiler.reportMessage(
           compiler.spanFromElement(field.getter),
           MessageKind.GETTER_MISMATCH.error([mismatchedFlags]),
-          api.Diagnostic.ERROR);
+          Diagnostic.ERROR);
       compiler.reportMessage(
           compiler.spanFromElement(field.setter),
           MessageKind.SETTER_MISMATCH.error([mismatchedFlags]),
-          api.Diagnostic.ERROR);
+          Diagnostic.ERROR);
     }
   }
 
   reportErrorWithContext(Element errorneousElement,
                          MessageKind errorMessage,
                          Element contextElement,
                          MessageKind contextMessage) {
     compiler.reportMessage(
         compiler.spanFromElement(errorneousElement),
         errorMessage.error([contextElement.name,
                             contextElement.getEnclosingClass().name]),
-        api.Diagnostic.ERROR);
+        Diagnostic.ERROR);
     compiler.reportMessage(
         compiler.spanFromElement(contextElement),
         contextMessage.error(),
-        api.Diagnostic.INFO);
+        Diagnostic.INFO);
   }
 
   void checkValidOverride(Element member, Element superMember) {
     if (superMember == null) return;
     if (member.modifiers.isStatic()) {
       reportErrorWithContext(
           member, MessageKind.NO_STATIC_OVERRIDE,
           superMember, MessageKind.NO_STATIC_OVERRIDE_CONT);
     } else {
       FunctionElement superFunction = superMember.asFunctionElement();
@@ skipping 2022 matching lines @@
       error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
     } else if (!element.impliesType()) {
       error(node, MessageKind.NOT_A_TYPE, [node]);
     } else {
       if (element.isClass()) {
         loadSupertype(element, node);
       } else {
         compiler.reportMessage(
           compiler.spanFromNode(node),
           MessageKind.TYPE_NAME_EXPECTED.error([]),
-          api.Diagnostic.ERROR);
+          Diagnostic.ERROR);
       }
     }
   }
 
   void visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix == null) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
       return;
     }
@@ skipping 190 matching lines @@
                                    NodeList formalParameters,
                                    Node returnNode,
                                    Element element) {
     SignatureResolver visitor = new SignatureResolver(compiler, element);
     Link<Element> parameters = const Link<Element>();
     int requiredParameterCount = 0;
     if (formalParameters == null) {
       if (!element.isGetter()) {
         compiler.reportMessage(compiler.spanFromElement(element),
                                MessageKind.MISSING_FORMALS.error([]),
-                               api.Diagnostic.ERROR);
+                               Diagnostic.ERROR);
       }
     } else {
       if (element.isGetter()) {
         if (!element.getLibrary().isPlatformLibrary) {
           // TODO(ahe): Remove the isPlatformLibrary check.
           if (!identical(formalParameters.getEndToken().next.stringValue, 'native')) {
             // TODO(ahe): Remove the check for native keyword.
             compiler.reportMessage(compiler.spanFromNode(formalParameters),
                                    MessageKind.EXTRA_FORMALS.error([]),
-                                   api.Diagnostic.WARNING);
+                                   Diagnostic.WARNING);
           }
         }
       }
       LinkBuilder<Element> parametersBuilder =
         visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount  = parametersBuilder.length;
       parameters = parametersBuilder.toLink();
     }
     DartType returnType = compiler.resolveReturnType(element, returnNode);
     return new FunctionSignature(parameters,
@@ skipping 399 matching lines @@
     return result;
   }
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in a patch library scope";
   }
   String toString() => 'PatchLibraryScope($origin,$patch)';
 }