Roll sdk dependency to 34357cdad108dcba734949bd13bd28c76ea285e0

pkg/fletchc/lib/incremental/fletchc_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 fletchc_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/elements/elements.dart' show
     ClassElement,
     ConstructorElement,
@@ skipping 115 matching lines @@
 
   FletchCompilerImplementation get compiler => _compiler;
 
   /// Perform a full compile of [script]. This will reset the incremental
   /// compiler.
   ///
   /// Notice: a full compile means not incremental. The part of the program
   /// that is compiled is determined by tree shaking.
   Future<bool> compile(Uri script) {
     _compiler = null;
-    return _reuseCompiler(null).then((Compiler compiler) {
+    return _reuseCompiler(null).then((CompilerImpl compiler) {
       _compiler = compiler;
       return compiler.run(script);
     });
   }
 
   /// Perform a full analysis of [script]. This will reset the incremental
   /// compiler.
   ///
   /// Notice: a full analysis is analogous to a full compile, that is, full
   /// analysis not incremental. The part of the program that is analyzed is
   /// determined by tree shaking.
   Future<int> analyze(Uri script) {
     _compiler = null;
     int initialErrorCount = _context.errorCount;
     int initialProblemCount = _context.problemCount;
-    return _reuseCompiler(null, analyzeOnly: true).then((Compiler compiler) {
+    return _reuseCompiler(null, analyzeOnly: true).then(
+        (CompilerImpl compiler) {
       // Don't try to reuse the compiler object.
       return compiler.run(script).then((_) {
         return _context.problemCount == initialProblemCount
             ? 0
             : _context.errorCount == initialErrorCount
                 ? exit_codes.ANALYSIS_HAD_NON_ERROR_PROBLEMS
                 : exit_codes.ANALYSIS_HAD_ERRORS;
       });
     });
   }
 
-  Future<Compiler> _reuseCompiler(
+  Future<CompilerImpl> _reuseCompiler(
       Future<bool> reuseLibrary(LibraryElement library),
       {bool analyzeOnly: false}) {
     List<String> options = this.options == null
         ? <String> [] : new List<String>.from(this.options);
     options.addAll(INCREMENTAL_OPTIONS);
     if (analyzeOnly) {
       options.add("--analyze-only");
     }
     return reuseCompiler(
         cachedCompiler: _compiler,
@@ skipping 36 matching lines @@
       Uri updatedFile = updatedFiles[uri];
       return inputProvider.readFromUri(updatedFile == null ? uri : updatedFile);
     }
     LibraryUpdater updater = new LibraryUpdater(
         _compiler,
         mappingInputProvider,
         logTime,
         logVerbose,
         _context);
     _context.registerUriWithUpdates(updatedFiles.keys);
-    return _reuseCompiler(updater.reuseLibrary).then((Compiler compiler) async {
+    return _reuseCompiler(updater.reuseLibrary).then(
+        (CompilerImpl compiler) async {
       _compiler = compiler;
       FletchDelta delta = await updater.computeUpdateFletch(currentSystem);
       _checkCompilationFailed();
       return delta;
     });
   }
 
   FletchDelta computeInitialDelta() {
     FletchBackend backend = _compiler.backend;
     return backend.computeDelta();
@@ skipping 78 matching lines @@
 
     case "production":
         return IncrementalMode.production;
 
     case "experimental":
       return IncrementalMode.experimental;
 
   }
   return null;
 }