Revert "Implement interface types."

lib/compiler/implementation/compiler.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 WorkItem {
   final Element element;
   TreeElements resolutionTree;
   Function run;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
@@ skipping 17 matching lines @@
   String codegen(Compiler compiler) {
     return compiler.codegen(this);
   }
 }
 
 class Compiler implements DiagnosticListener {
   Queue<WorkItem> worklist;
   Universe universe;
   String assembledCode;
   Namer namer;
-  final Types types;
+  Types types;
 
   final Tracer tracer;
 
   CompilerTask measuredTask;
   Element _currentElement;
   LibraryElement coreLibrary;
   LibraryElement coreImplLibrary;
   LibraryElement isolateLibrary;
   LibraryElement jsHelperLibrary;
   LibraryElement mainApp;
@@ skipping 166 matching lines @@
   void initializeSpecialClasses() {
     objectClass = coreLibrary.find(const SourceString('Object'));
     boolClass = coreLibrary.find(const SourceString('bool'));
     numClass = coreLibrary.find(const SourceString('num'));
     intClass = coreLibrary.find(const SourceString('int'));
     doubleClass = coreLibrary.find(const SourceString('double'));
     stringClass = coreLibrary.find(const SourceString('String'));
     functionClass = coreLibrary.find(const SourceString('Function'));
     listClass = coreLibrary.find(const SourceString('List'));
     closureClass = jsHelperLibrary.find(const SourceString('Closure'));
-    dynamicClass = types.dynamicType.element;
+    dynamicClass = jsHelperLibrary.find(const SourceString('Dynamic'));
     nullClass = jsHelperLibrary.find(const SourceString('Null'));
   }
 
   void scanBuiltinLibraries() {
     coreImplLibrary = scanBuiltinLibrary('coreimpl');
     jsHelperLibrary = scanBuiltinLibrary('_js_helper');
     coreLibrary = scanBuiltinLibrary('core');
 
     // Since coreLibrary import the libraries "coreimpl", and
     // "js_helper", coreLibrary is null when they are being built. So
@@ skipping 23 matching lines @@
         const SourceString('JS_CURRENT_ISOLATE'), library), this);
     library.define(new ForeignElement(
         const SourceString('JS_CALL_IN_ISOLATE'), library), this);
     library.define(new ForeignElement(
         const SourceString('DART_CLOSURE_TO_JS'), library), this);
   }
 
   void runCompiler(Uri uri) {
     scanBuiltinLibraries();
     mainApp = scanner.loadLibrary(uri, null);
-    final Element mainElement = mainApp.find(MAIN);
-    if (mainElement === null) {
+    final Element mainMethod = mainApp.find(MAIN);
+    if (mainMethod === null) {
       withCurrentElement(mainApp, () => cancel('Could not find $MAIN'));
     } else {
-      withCurrentElement(mainElement, () {
-        if (!mainElement.isFunction()) {
-          cancel('main is not a function', element: mainElement);
+      withCurrentElement(mainMethod, () {
+        if (!mainMethod.isFunction()) {
+          cancel('main is not a function', element: mainMethod);
         }
-        FunctionElement mainMethod = mainElement;
         FunctionParameters parameters = mainMethod.computeParameters(this);
         if (parameters.parameterCount > 0) {
           cancel('main cannot have parameters', element: mainMethod);
         }
       });
     }
     native.processNativeClasses(this, universe.libraries.getValues());
-    enqueue(new WorkItem.toCompile(mainElement));
+    enqueue(new WorkItem.toCompile(mainMethod));
     codegenProgress.reset();
     while (!worklist.isEmpty()) {
       WorkItem work = worklist.removeLast();
       withCurrentElement(work.element, () => (work.run)(this));
     }
     workListIsClosed = true;
     assert(enqueuer.checkNoEnqueuedInvokedInstanceMethods());
     enqueuer.registerFieldClosureInvocations();
     emitter.assembleProgram();
     if (!worklist.isEmpty()) {
@@ skipping 104 matching lines @@
                               () => resolver.resolveSignature(element));
   }
 
   Constant compileVariable(VariableElement element) {
     return withCurrentElement(element, () {
       return constantHandler.compileVariable(element);
     });
   }
 
   reportWarning(Node node, var message) {
-    if (message is TypeWarning) {
+    if (message is ResolutionWarning) {
+      // TODO(ahe): Don't supress this warning when we support type variables.
+      if (message.message.kind === MessageKind.CANNOT_RESOLVE_TYPE) return;
+    } else if (message is TypeWarning) {
       // TODO(ahe): Don't supress these warning when the type checker
       // is more complete.
       if (message.message.kind === MessageKind.NOT_ASSIGNABLE) return;
       if (message.message.kind === MessageKind.MISSING_RETURN) return;
       if (message.message.kind === MessageKind.ADDITIONAL_ARGUMENT) return;
       if (message.message.kind === MessageKind.METHOD_NOT_FOUND) return;
     }
     SourceSpan span = spanFromNode(node);
     reportDiagnostic(span, "${magenta('warning:')} $message", false);
   }
@@ skipping 118 matching lines @@
   }
 }
 
 class SourceSpan {
   final Uri uri;
   final int begin;
   final int end;
 
   const SourceSpan(this.uri, this.begin, this.end);
 }