Generate a warning and a runtime error for calls to nonexistent static calls, getters and setters.

lib/compiler/implementation/resolver.dart

Index: lib/compiler/implementation/resolver.dart
diff --git a/lib/compiler/implementation/resolver.dart b/lib/compiler/implementation/resolver.dart
index 4b6a8f49fdbe5ed61d7e91227689569694408830..40d4172bcaeeb41424d721eb3be31c3882b3a5e2 100644
--- a/lib/compiler/implementation/resolver.dart
+++ b/lib/compiler/implementation/resolver.dart
@@ -990,8 +990,8 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
     TargetElement element = mapping[statement];
     if (element === null) {
       element = new TargetElement(statement,
-                                     statementScope.nestingLevel,
-                                     enclosingElement);
+                                  statementScope.nestingLevel,
+                                  enclosingElement);
       mapping[statement] = element;
     }
     return element;
@@ -1009,6 +1009,15 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
     inStaticContext(() => visit(node));
   }
 
+  ErroneousElement warnAndCreateErroneousElement(Node node,
+                                                 SourceString name,
+                                                 MessageKind kind,
+                                                 List<Node> arguments) {
+    ResolutionWarning warning = new ResolutionWarning(kind, arguments);
+    compiler.reportWarning(node, warning);
+    return new ErroneousElement(warning.message, name, enclosingElement);
+  }
+
   Element visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
@@ -1229,13 +1238,15 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
       target = currentClass.lookupSuperMember(name);
       // [target] may be null which means invoking noSuchMethod on
       // super.
-    } else if (Element.isInvalid(resolvedReceiver)) {
+    } else if (Element.isUnresolved(resolvedReceiver)) {
       return null;
     } else if (resolvedReceiver.kind === ElementKind.CLASS) {
       ClassElement receiverClass = resolvedReceiver;
       target = receiverClass.ensureResolved(compiler).lookupLocalMember(name);
       if (target === null) {
-        error(node, MessageKind.METHOD_NOT_FOUND, [receiverClass.name, name]);
+        return warnAndCreateErroneousElement(node, name,
+                                             MessageKind.METHOD_NOT_FOUND,
+                                             [receiverClass.name, name]);
       } else if (target.isInstanceMember()) {
         error(node, MessageKind.MEMBER_NOT_STATIC, [receiverClass.name, name]);
       }
@@ -1332,12 +1343,11 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
 
   visitSend(Send node) {
     Element target = resolveSend(node);
-    if (!Element.isInvalid(target)
+    if (!Element.isUnresolved(target)
         && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       target = field.getter;
-      if (Element.isInvalid(target) && !inInstanceContext) {
-        // TODO(karlklose): make this a runtime error.
+      if (Element.isUnresolved(target) && !inInstanceContext) {
         error(node.selector, MessageKind.CANNOT_RESOLVE_GETTER);
       }
     }
@@ -1372,7 +1382,7 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
     if (node.isCall &&
-        (Element.isInvalid(target) ||
+        (Element.isUnresolved(target) ||
          target.isGetter() ||
          Elements.isClosureSend(node, target))) {
       Selector call = new Selector.callClosureFrom(selector);
@@ -1402,16 +1412,15 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
     Element getter = target;
     String source = node.assignmentOperator.source.stringValue;
     bool isComplex = source !== '=';
-    if (target != null && target.kind == ElementKind.ABSTRACT_FIELD) {
+    if (!Element.isUnresolved(target)
+        && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       setter = field.setter;
       getter = field.getter;
-      if (Element.isInvalid(setter) && !inInstanceContext) {
-        // TODO(karlklose): make this a runtime error.
+      if (setter == null && !inInstanceContext) {
         error(node.selector, MessageKind.CANNOT_RESOLVE_SETTER);
       }
-      if (isComplex && Element.isInvalid(getter) && !inInstanceContext) {
-        // TODO(karlklose): make this a runtime error.
+      if (isComplex && getter == null && !inInstanceContext) {
         error(node.selector, MessageKind.CANNOT_RESOLVE_GETTER);
       }
     }
@@ -1541,7 +1550,7 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
     resolveSelector(node.send);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
-    if (Element.isInvalid(constructor)) return constructor;
+    if (Element.isUnresolved(constructor)) return constructor;
     // TODO(karlklose): handle optional arguments.
     if (node.send.argumentCount() != constructor.parameterCount(compiler)) {
       // TODO(ngeoffray): resolution error with wrong number of
@@ -1577,7 +1586,7 @@ class ResolverVisitor extends CommonResolverVisitor<Element> {
     FunctionElement constructor = node.accept(visitor);
     // Try to resolve the type that the new-expression constructs.
     TypeAnnotation annotation = node.send.getTypeAnnotation();
-    if (Element.isInvalid(constructor)) {
+    if (Element.isUnresolved(constructor)) {
       // Resolve the type arguments. We cannot create a type and check the
       // number of type arguments for this annotation, because we do not know
       // the element.
@@ -2460,13 +2469,15 @@ class ConstructorResolver extends CommonResolverVisitor<Element> {
   }
 
   failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
-                               MessageKind kind, List arguments) {
+                               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, enclosing);
+      return new ErroneousFunctionElement(warning.message, targetName,
+                                          enclosing);
     }
   }
 
@@ -2482,6 +2493,7 @@ class ConstructorResolver extends CommonResolverVisitor<Element> {
                               '.${constructorName.slowToString()}';
       }
       return failOrReturnErroneousElement(cls, diagnosticNode,
+                                          new SourceString(fullConstructorName),
                                           MessageKind.CANNOT_FIND_CONSTRUCTOR,
                                           [fullConstructorName]);
     }
@@ -2491,7 +2503,7 @@ class ConstructorResolver extends CommonResolverVisitor<Element> {
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     Element e = visit(selector);
-    if (!Element.isInvalid(e) && e.kind === ElementKind.CLASS) {
+    if (!Element.isUnresolved(e) && e.kind === ElementKind.CLASS) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       if (cls.isInterface() && (cls.defaultClass === null)) {
@@ -2508,7 +2520,7 @@ class ConstructorResolver extends CommonResolverVisitor<Element> {
 
   visitSend(Send node) {
     Element e = visit(node.receiver);
-    if (Element.isInvalid(e)) return e;
+    if (Element.isUnresolved(e)) return e;
     Identifier name = node.selector.asIdentifier();
     if (name === null) internalError(node.selector, 'unexpected node');
 
@@ -2525,6 +2537,7 @@ class ConstructorResolver extends CommonResolverVisitor<Element> {
       e = prefix.lookupLocalMember(name.source);
       if (e === null) {
         return failOrReturnErroneousElement(resolver.enclosingElement, name,
+                                            name.source,
                                             MessageKind.CANNOT_RESOLVE,
                                             [name]);
       } else if (e.kind !== ElementKind.CLASS) {
@@ -2540,7 +2553,7 @@ class ConstructorResolver extends CommonResolverVisitor<Element> {
     SourceString name = node.source;
     Element e = resolver.lookup(node, name);
     if (e === null) {
-      return failOrReturnErroneousElement(resolver.enclosingElement, node,
+      return failOrReturnErroneousElement(resolver.enclosingElement, node, name,
                                           MessageKind.CANNOT_RESOLVE, [name]);
     } else if (e.kind === ElementKind.TYPEDEF) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF, [name]);