Implement override checks.

dart/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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 final bool REPORT_EXCESS_RESOLUTION = false;
@@ skipping 285 matching lines @@
   bool enabledNoSuchMethod = false;
 
   Stopwatch progress;
 
   static final int PHASE_SCANNING = 0;
   static final int PHASE_RESOLVING = 1;
   static final int PHASE_COMPILING = 2;
   static final int PHASE_RECOMPILING = 3;
   int phase;
 
+  bool compilationFailed = false;
+
   Compiler([this.tracer = const Tracer(),
             this.enableTypeAssertions = false,
             this.enableUserAssertions = false,
             bool emitJavascript = true,
             validateUnparse = false,
             generateSourceMap = true])
       : libraries = new Map<String, LibraryElement>(),
         world = new World(),
         progress = new Stopwatch.start() {
     namer = new Namer(this);
@@ skipping 225 matching lines @@
     // TODO(ahe): Remove this line. Eventually, enqueuer.resolution
     // should know this.
     world.populate(this, libraries.getValues());
 
     log('Resolving...');
     phase = PHASE_RESOLVING;
     backend.enqueueHelpers(enqueuer.resolution);
     processQueue(enqueuer.resolution, main);
     log('Resolved ${enqueuer.resolution.resolvedElements.length} elements.');
 
+    if (compilationFailed) return;
+
     log('Compiling...');
     phase = PHASE_COMPILING;
     processQueue(enqueuer.codegen, main);
     log("Recompiling ${enqueuer.codegen.recompilationCandidates.length} "
         "methods...");
     phase = PHASE_RECOMPILING;
     processRecompilationQueue(enqueuer.codegen);
     log('Compiled ${codegenWorld.generatedCode.length} methods.');
 
+    if (compilationFailed) return;
+
     backend.assembleProgram();
 
     checkQueues();
   }
 
   void processQueue(Enqueuer world, Element main) {
     backend.processNativeClasses(world, libraries.getValues());
     world.addToWorkList(main);
     progress.reset();
     world.forEach((WorkItem work) {
@@ skipping 178 matching lines @@
       // 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.MAYBE_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, 'Warning: $message', api.Diagnostic.WARNING );
+    reportDiagnostic(span, 'Warning: $message', api.Diagnostic.WARNING);
   }
 
   reportError(Node node, var message) {
     SourceSpan span = spanFromNode(node);
     reportDiagnostic(span, 'Error: $message', api.Diagnostic.ERROR);
     throw new CompilerCancelledException(message.toString());
   }
 
+  void reportMessage(SourceSpan span,
+                     Diagnostic message,
+                     api.Diagnostic kind) {
+    // TODO(ahe): The names Diagnostic and api.Diagnostic are in
+    // conflict. Fix it.
+    reportDiagnostic(span, "$message", kind);
+  }
+
   abstract void reportDiagnostic(SourceSpan span, String message,
                                  api.Diagnostic kind);
 
   SourceSpan spanFromTokens(Token begin, Token end, [Uri uri]) {
     if (begin === null || end === null) {
       // TODO(ahe): We can almost always do better. Often it is only
       // end that is null. Otherwise, we probably know the current
       // URI.
       throw 'Cannot find tokens to produce error message.';
     }
@@ skipping 107 matching lines @@
     // invariant that endOffset > beginOffset, but for EOF the
     // charoffset of the next token may be [beginOffset]. This can
     // also happen for synthetized tokens that are produced during
     // error handling.
     final endOffset =
       Math.max((end.next !== null) ? end.next.charOffset : 0, beginOffset + 1);
     assert(endOffset > beginOffset);
     return f(beginOffset, endOffset);
   }
 }