Implement --analyze-all option.

dart/sdk/lib/_internal/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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 58 matching lines @@
   }
 }
 
 class ResolverTask extends CompilerTask {
   ResolverTask(Compiler compiler) : super(compiler);
 
   String get name => 'Resolver';
 
   TreeElements resolve(Element element) {
     return measure(() {
+      if (Elements.isErroneousElement(element)) return null;
+
+      for (MetadataAnnotation metadata in element.metadata) {
+        metadata.ensureResolved(compiler);
+      }
+
       ElementKind kind = element.kind;
       if (identical(kind, ElementKind.GENERATIVE_CONSTRUCTOR) ||
           identical(kind, ElementKind.FUNCTION) ||
           identical(kind, ElementKind.GETTER) ||
           identical(kind, ElementKind.SETTER)) {
         return resolveMethodElement(element);
       }
 
       if (identical(kind, ElementKind.FIELD)) return resolveField(element);
 
       if (identical(kind, ElementKind.PARAMETER) ||
           identical(kind, ElementKind.FIELD_PARAMETER)) {
         return resolveParameter(element);
       }
+      if (element.isClass()) {
+        ClassElement cls = element;
+        cls.ensureResolved(compiler);
+        return null;
+      } else if (element.isTypedef() || element.isTypeVariable()) {
+        element.computeType(compiler);
+        return null;
+      }
 
       compiler.unimplemented("resolve($element)",
                              node: element.parseNode(compiler));
     });
   }
 
   String constructorNameForDiagnostics(SourceString className,
                                    SourceString constructorName) {
     String classNameString = className.slowToString();
     String constructorNameString = constructorName.slowToString();
@@ skipping 335 matching lines @@
       element.defaultClass = element.origin.defaultClass;
       element.interfaces = element.origin.interfaces;
       element.allSupertypes = element.origin.allSupertypes;
       // Stepwise assignment to ensure invariant.
       element.supertypeLoadState = STATE_STARTED;
       element.supertypeLoadState = STATE_DONE;
       element.resolutionState = STATE_DONE;
       // TODO(johnniwinther): Check matching type variables and
       // empty extends/implements clauses.
     }
+    for (MetadataAnnotation metadata in element.metadata) {
+      metadata.ensureResolved(compiler);
+    }
   }
 
   void checkMembers(ClassElement cls) {
     assert(invariant(cls, cls.isDeclaration));
     if (cls.isObject(compiler)) return;
     // TODO(johnniwinther): Should this be done on the implementation element as
     // well?
     cls.forEachMember((holder, member) {
       // Perform various checks as side effect of "computing" the type.
       member.computeType(compiler);
@@ skipping 163 matching lines @@
   void resolveMetadataAnnotation(PartialMetadataAnnotation annotation) {
     compiler.withCurrentElement(annotation.annotatedElement, () => measure(() {
       assert(annotation.resolutionState == STATE_NOT_STARTED);
       annotation.resolutionState = STATE_STARTED;
 
       Node node = annotation.parseNode(compiler);
       ResolverVisitor visitor =
           visitorFor(annotation.annotatedElement.enclosingElement);
       node.accept(visitor);
       annotation.value = compiler.constantHandler.compileNodeWithDefinitions(
-          node, visitor.mapping);
+          node, visitor.mapping, isConst: true);
 
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError message = new ResolutionError(kind, arguments);
     compiler.reportError(node, message);
   }
 }
@@ skipping 552 matching lines @@
       inCheckContext = compiler.enableTypeAssertions,
       inCatchBlock = false,
       super(compiler);
 
   Enqueuer get world => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
     if (!Elements.isUnresolved(result)) {
       if (!inInstanceContext && result.isInstanceMember()) {
-        error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
-        // TODO(johnniwinther): Create an ErroneousElement.
+        compiler.reportMessage(compiler.spanFromNode(node),
+            MessageKind.NO_INSTANCE_AVAILABLE.error([name]),
+            Diagnostic.ERROR);
+        return new ErroneousElement(MessageKind.NO_INSTANCE_AVAILABLE,
+                                    [name],
+                                    name, enclosingElement);
       } else if (result.isAmbiguous()) {
         AmbiguousElement ambiguous = result;
         compiler.reportMessage(compiler.spanFromNode(node),
             ambiguous.messageKind.error(ambiguous.messageArguments),
             Diagnostic.ERROR);
         return new ErroneousElement(ambiguous.messageKind,
                                     ambiguous.messageArguments,
                                     name, enclosingElement);
       }
     }
@@ skipping 1857 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }