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

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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 972 matching lines @@
       error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
     }
     return result;
   }
 
   // Create, or reuse an already created, statement element for a statement.
   TargetElement getOrCreateTargetElement(Node statement) {
     TargetElement element = mapping[statement];
     if (element === null) {
       element = new TargetElement(statement,
-                                     statementScope.nestingLevel,
-                                     enclosingElement);
+                                  statementScope.nestingLevel,
+                                  enclosingElement);
       mapping[statement] = element;
     }
     return element;
   }
 
   inStaticContext(action()) {
     bool wasInstanceContext = inInstanceContext;
     inInstanceContext = false;
     var result = action();
     inInstanceContext = wasInstanceContext;
     return result;
   }
 
   visitInStaticContext(Node node) {
     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) {
         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);
@@ skipping 200 matching lines @@
         return null;
       }
       if (currentClass.supertype === null) {
         // This is just to guard against internal errors, so no need
         // for a real error message.
         error(node.receiver, MessageKind.GENERIC, ["Object has no superclass"]);
       }
       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]);
       }
     } else if (resolvedReceiver.kind === ElementKind.PREFIX) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
       if (target == null) {
         error(node, MessageKind.NO_SUCH_LIBRARY_MEMBER, [prefix.name, name]);
       }
     }
@@ skipping 76 matching lines @@
       if (argument.asNamedArgument() != null) {
         seenNamedArgument = true;
       } else if (seenNamedArgument) {
         error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
       }
     }
   }
 
   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);
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (operatorString === 'is' || operatorString === 'as') {
         assert(node.arguments.tail.isEmpty());
         resolveTypeTest(node.arguments.head);
@@ skipping 14 matching lines @@
 
     // If the selector is null, it means that we will not be generating
     // code for this as a send.
     Selector selector = mapping.getSelector(node);
     if (selector === null) return;
 
     // If we don't know what we're calling or if we are calling a getter,
     // 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);
       world.registerDynamicInvocation(call.name, call);
     }
 
     // TODO(ngeoffray): We should do the check in
     // visitExpressionStatement instead.
     if (target === compiler.assertMethod && !node.isCall) {
       // We can only use assert by calling it.
       if (!inInstanceContext) {
         error(node, MessageKind.MISSING_ARGUMENTS_TO_ASSERT, [node]);
       }
       target = null;
     }
 
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
     useElement(node, target);
     registerSend(selector, target);
     return node.isPropertyAccess ? target : null;
   }
 
   visitSendSet(SendSet node) {
     Element target = resolveSend(node);
     Element setter = target;
     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);
       }
     }
 
     visit(node.argumentsNode);
 
     // TODO(ngeoffray): Check if the target can be assigned.
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
 
@@ skipping 109 matching lines @@
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     FunctionElement constructor = resolveConstructor(node);
     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
       // parameters. We cannot do this rigth now because of the
       // List constructor.
     }
     world.registerStaticUse(constructor);
     compiler.withCurrentElement(constructor, () {
       FunctionExpression tree = constructor.parseNode(compiler);
       compiler.resolver.resolveConstructorImplementation(constructor, tree);
@@ skipping 15 matching lines @@
    * Note: this function may return an ErroneousFunctionElement instead of
    * [null], if there is no corresponding constructor, class or library.
    */
   FunctionElement resolveConstructor(NewExpression node) {
     // Resolve the constructor that [node] refers to.
     ConstructorResolver visitor =
         new ConstructorResolver(compiler, this, node.isConst());
     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.
       Link arguments = const EmptyLink<Node>();
       if (annotation.typeArguments != null) {
         arguments = annotation.typeArguments.nodes;
       }
       for (Node argument in arguments) {
         resolveTypeRequired(argument);
       }
@@ skipping 862 matching lines @@
 
   ConstructorResolver(Compiler compiler, this.resolver,
                       [bool this.inConstContext = false])
       : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
   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);
     }
   }
 
   FunctionElement lookupConstructor(ClassElement cls,
                                     Node diagnosticNode,
                                     SourceString constructorName) {
     cls.ensureResolved(compiler);
     Element result = cls.lookupConstructor(cls.name, constructorName);
     if (result === null) {
       String fullConstructorName = cls.name.slowToString();
       if (constructorName !== const SourceString('')) {
         fullConstructorName = '$fullConstructorName'
                               '.${constructorName.slowToString()}';
       }
       return failOrReturnErroneousElement(cls, diagnosticNode,
+                                          new SourceString(fullConstructorName),
                                           MessageKind.CANNOT_FIND_CONSTRUCTOR,
                                           [fullConstructorName]);
     }
     return result;
   }
 
   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)) {
         error(selector, MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
       }
       e = lookupConstructor(cls, selector, const SourceString(''));
     }
     return e;
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     return visit(node.typeName);
   }
 
   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');
 
     if (e.kind === ElementKind.CLASS) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       if (cls.isInterface() && (cls.defaultClass === null)) {
         error(node.receiver, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
               [cls.name]);
       }
       return lookupConstructor(cls, name, name.source);
     } else if (e.kind === ElementKind.PREFIX) {
       PrefixElement prefix = e;
       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) {
         error(node, MessageKind.NOT_A_TYPE, [name]);
       }
     } else {
       internalError(node.receiver, 'unexpected element $e');
     }
     return e;
   }
 
   Element visitIdentifier(Identifier node) {
     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]);
     } else if (e.kind !== ElementKind.CLASS && e.kind !== ElementKind.PREFIX) {
       error(node, MessageKind.NOT_A_TYPE, [name]);
     }
     return e;
   }
 }
 
@@ skipping 112 matching lines @@
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }