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

lib/compiler/implementation/typechecker.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.
 
 class TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name => "Type checker";
 
   static const bool LOG_FAILURES = false;
 
@@ skipping 377 matching lines @@
   DartType visitFunctionDeclaration(FunctionDeclaration node) {
     analyze(node.function);
     return StatementType.NOT_RETURNING;
   }
 
   DartType visitFunctionExpression(FunctionExpression node) {
     DartType type;
     DartType returnType;
     DartType previousType;
     final FunctionElement element = elements[node];
-    if (Element.isInvalid(element)) return types.dynamicType;
+    if (Element.isUnresolved(element)) return types.dynamicType;
     if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR ||
         element.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
       type = types.dynamicType;
       returnType = types.voidType;
     } else {
       FunctionType functionType = computeType(element);
       returnType = functionType.returnType;
       type = functionType;
     }
     DartType previous = expectedReturnType;
@@ skipping 157 matching lines @@
           if (receiverKind !== ElementKind.CLASS) {
             fail(node.receiver, 'unexpected receiver kind: ${receiverKind}');
           }
           ClassElement classElement = receiverType.element;
           // TODO(karlklose): substitute type arguments.
           DartType memberType =
             lookupMethodType(selector, classElement, selector.source);
           if (memberType.element === compiler.dynamicClass) return null;
           return memberType;
         } else {
-          if (element === null) {
+          if (Element.isUnresolved(element)) {
             fail(node, 'unresolved ${node.selector}');
           } else if (element.kind === ElementKind.FUNCTION) {
             return computeType(element);
           } else if (element.kind === ElementKind.FOREIGN) {
             return null;
           } else if (element.kind === ElementKind.VARIABLE
                      || element.kind === ElementKind.FIELD) {
             // TODO(karlklose): handle object invocations.
             return null;
           } else {
@@ skipping 116 matching lines @@
     }
     return StatementType.RETURNING;
   }
 
   DartType visitThrow(Throw node) {
     if (node.expression !== null) analyze(node.expression);
     return StatementType.RETURNING;
   }
 
   DartType computeType(Element element) {
-    if (Element.isInvalid(element)) return types.dynamicType;
+    if (Element.isUnresolved(element)) return types.dynamicType;
     DartType result = element.computeType(compiler);
     return (result !== null) ? result : types.dynamicType;
   }
 
   DartType visitTypeAnnotation(TypeAnnotation node) {
     return elements.getType(node);
   }
 
   visitTypeVariable(TypeVariable node) {
     return types.dynamicType;
@@ skipping 120 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     return unhandledStatement();
   }
 
   visitTypedef(Typedef node) {
     return unhandledStatement();
   }
 }