Rename apiimpl.Compiler to CompilerImpl.

pkg/dart2js_incremental/lib/dart2js_incremental.dart

 // Copyright (c) 2014, 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.
 
 library dart2js_incremental;
 
 import 'dart:async' show
     EventSink,
     Future;
 
 import 'dart:developer' show
     UserTag;
 
 import 'package:compiler/src/apiimpl.dart' show
-    Compiler;
+    CompilerImpl;
 
 import 'package:compiler/compiler_new.dart' show
     CompilerDiagnostics,
     CompilerInput,
     CompilerOutput,
     Diagnostic;
 
 import 'package:compiler/src/null_compiler_output.dart' show
     NullCompilerOutput;
 
@@ skipping 26 matching lines @@
   final Uri libraryRoot;
   final Uri packageRoot;
   final CompilerInput inputProvider;
   final CompilerDiagnostics diagnosticHandler;
   final List<String> options;
   final CompilerOutput outputProvider;
   final Map<String, dynamic> environment;
   final List<String> _updates = <String>[];
   final IncrementalCompilerContext _context = new IncrementalCompilerContext();
 
-  Compiler _compiler;
+  CompilerImpl _compiler;
 
   IncrementalCompiler({
       this.libraryRoot,
       this.packageRoot,
       this.inputProvider,
       this.diagnosticHandler,
       this.options,
       this.outputProvider,
       this.environment}) {
     if (libraryRoot == null) {
       throw new ArgumentError('libraryRoot is null.');
     }
     if (inputProvider == null) {
       throw new ArgumentError('inputProvider is null.');
     }
     if (outputProvider == null) {
       throw new ArgumentError('outputProvider is null.');
     }
     if (diagnosticHandler == null) {
       throw new ArgumentError('diagnosticHandler is null.');
     }
     _context.incrementalCompiler = this;
   }
 
   LibraryElement get mainApp => _compiler.mainApp;
 
-  Compiler get compiler => _compiler;
+  CompilerImpl get compiler => _compiler;
 
   Future<bool> compile(Uri script) {
-    return _reuseCompiler(null).then((Compiler compiler) {
+    return _reuseCompiler(null).then((CompilerImpl compiler) {
       _compiler = compiler;
       return compiler.run(script);
     });
   }
 
-  Future<Compiler> _reuseCompiler(
+  Future<CompilerImpl> _reuseCompiler(
       Future<bool> reuseLibrary(LibraryElement library)) {
     List<String> options = this.options == null
         ? <String> [] : new List<String>.from(this.options);
     options.addAll(INCREMENTAL_OPTIONS);
     return reuseCompiler(
         cachedCompiler: _compiler,
         libraryRoot: libraryRoot,
         packageRoot: packageRoot,
         inputProvider: inputProvider,
         diagnosticHandler: diagnosticHandler,
@@ skipping 17 matching lines @@
       Uri updatedFile = updatedFiles[uri];
       return inputProvider(updatedFile == null ? uri : updatedFile);
     }
     LibraryUpdater updater = new LibraryUpdater(
         _compiler,
         mappingInputProvider,
         logTime,
         logVerbose,
         _context);
     _context.registerUriWithUpdates(updatedFiles.keys);
-    Future<Compiler> future = _reuseCompiler(updater.reuseLibrary);
+    Future<CompilerImpl> future = _reuseCompiler(updater.reuseLibrary);
     return future.then((Compiler compiler) {
       _compiler = compiler;
       if (compiler.compilationFailed) {
         return null;
       } else {
         String update = updater.computeUpdateJs();
         _updates.add(update);
         return update;
       }
     });
@@ skipping 16 matching lines @@
   }
 }
 
 class IncrementalCompilationFailed {
   final String reason;
 
   const IncrementalCompilationFailed(this.reason);
 
   String toString() => "Can't incrementally compile program.\n\n$reason";
 }