Revert "Implement call operator."

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 final bool LOG_FAILURES = false;
 
@@ skipping 403 matching lines @@
       if (!arguments.isEmpty()) {
         reportTypeWarning(arguments.head, MessageKind.ADDITIONAL_ARGUMENT);
       } else if (!parameterTypes.isEmpty()) {
         reportTypeWarning(send, MessageKind.MISSING_ARGUMENT,
                           [parameterTypes.head]);
       }
     }
   }
 
   Type visitSend(Send node) {
-    Element element = elements[node];
-
-    if (Elements.isClosureSend(node, element)) {
+    if (Elements.isClosureSend(node, elements)) {
       // TODO(karlklose): Finish implementation.
       return types.dynamicType;
     }
 
     Identifier selector = node.selector.asIdentifier();
     String name = selector.source.stringValue;
 
     if (node.isOperator && name === 'is') {
       analyze(node.receiver);
       return boolType;
@@ skipping 22 matching lines @@
         }
         return boolType;
       }
       fail(selector, 'unexpected operator ${name}');
 
     } else if (node.isPropertyAccess) {
       if (node.receiver !== null) {
         // TODO(karlklose): we cannot handle fields.
         return unhandledExpression();
       }
+      Element element = elements[node];
       if (element === null) return types.dynamicType;
       return computeType(element);
 
     } else if (node.isFunctionObjectInvocation) {
       fail(node.receiver, 'function object invocation unimplemented');
 
     } else {
       FunctionType computeFunType() {
         if (node.receiver !== null) {
           Type receiverType = analyze(node.receiver);
@@ skipping 17 matching lines @@
           if (receiverKind !== ElementKind.CLASS) {
             fail(node.receiver, 'unexpected receiver kind: ${receiverKind}');
           }
           ClassElement classElement = receiverType.element;
           // TODO(karlklose): substitute type arguments.
           Type memberType =
             lookupMethodType(selector, classElement, selector.source);
           if (memberType.element === compiler.dynamicClass) return null;
           return memberType;
         } else {
+          Element element = elements[node];
           if (element === null) {
             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;
@@ skipping 258 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     return unhandledStatement();
   }
 
   visitTypedef(Typedef node) {
     return unhandledStatement();
   }
 }