Import scope rules updated.

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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 886 matching lines @@
     return resolveTypeAnnotationInContext(inScope, node, onFailure,
                                           whenResolved);
   }
 
   DartType resolveTypeAnnotationInContext(Scope scope, TypeAnnotation node,
                                           onFailure, whenResolved) {
     Element element = resolveTypeName(scope, node);
     DartType type;
     if (element === null) {
       onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
+    } else if (element.isErroneous()) {
+      ErroneousElement error = element;
+      onFailure(node, error.messageKind, error.messageArguments);
     } else if (!element.impliesType()) {
       onFailure(node, MessageKind.NOT_A_TYPE, [node.typeName]);
     } else {
       if (element === compiler.types.voidType.element ||
           element === compiler.types.dynamicType.element) {
         type = element.computeType(compiler);
       } else if (element.isClass()) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         Link<DartType> arguments =
@@ skipping 127 matching lines @@
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
   ErroneousElement warnAndCreateErroneousElement(Node node,
                                                  SourceString name,
                                                  MessageKind kind,
                                                  List<Node> arguments) {
-    ResolutionWarning warning = new ResolutionWarning(kind, arguments);
+    return warnOnErroneousElement(node,
+        new ErroneousElement(kind, arguments, name, enclosingElement));
+  }
+
+  ErroneousElement warnOnErroneousElement(Node node,
+                                          ErroneousElement erroneousElement) {
+    ResolutionWarning warning =
+        new ResolutionWarning(erroneousElement.messageKind,
+                              erroneousElement.messageArguments);
     compiler.reportWarning(node, warning);
-    return new ErroneousElement(warning.message, name, enclosingElement);
+    return erroneousElement;
   }
 
   Element visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
       }
       return null;
     } else if (node.isSuper()) {
       if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return null;
     } else {
       Element element = lookup(node, node.source);
       if (element === null) {
         if (!inInstanceContext) {
           element = warnAndCreateErroneousElement(node, node.source,
                                                   MessageKind.CANNOT_RESOLVE,
                                                   [node]);
         }
+      } else if (element.isErroneous()) {
+        element = warnOnErroneousElement(node, element);
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC, ["is not an expression $element"]);
         }
       }
       return useElement(node, element);
     }
   }
 
@@ skipping 1528 matching lines @@
   }
 
   failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
                                SourceString targetName, MessageKind kind,
                                List arguments) {
     if (inConstContext) {
       error(diagnosticNode, kind, arguments);
     } else {
       ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
       compiler.reportWarning(diagnosticNode, warning);
-      return new ErroneousFunctionElement(warning.message, targetName,
+      return new ErroneousFunctionElement(kind, arguments, targetName,
                                           enclosing);
     }
   }
 
   // TODO(ngeoffray): method named lookup should not report errors.
   FunctionElement lookupConstructor(ClassElement cls,
                                     Node diagnosticNode,
                                     SourceString constructorName) {
     cls.ensureResolved(compiler);
     Element result = cls.lookupConstructor(cls.name, constructorName);
@@ skipping 220 matching lines @@
 
   Element localLookup(SourceString name) => library.find(name);
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }