Remove code supporting incremental compilation in dart2js

pkg/compiler/lib/src/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.
 
 library dart2js.compiler_base;
 
 import 'dart:async' show EventSink, Future;
 
 import '../compiler_new.dart' as api;
-import 'cache_strategy.dart' show CacheStrategy;
 import 'closure.dart' as closureMapping show ClosureTask;
 import 'common/backend_api.dart' show Backend;
 import 'common/names.dart' show Selectors;
 import 'common/names.dart' show Identifiers, Uris;
 import 'common/resolution.dart'
     show
         ParsingContext,
         Resolution,
         ResolutionWorkItem,
         ResolutionImpact,
@@ skipping 72 matching lines @@
 abstract class Compiler implements LibraryLoaderListener {
   Measurer get measurer;
 
   final IdGenerator idGenerator = new IdGenerator();
   Types types;
   _CompilerCommonElements _commonElements;
   CompilerDiagnosticReporter _reporter;
   CompilerResolution _resolution;
   ParsingContext _parsingContext;
 
-  final CacheStrategy cacheStrategy;
-
   ImpactStrategy impactStrategy = const ImpactStrategy();
 
   /**
    * Map from token to the first preceding comment token.
    */
   final TokenMap commentMap = new TokenMap();
 
   /**
    * Records global dependencies, that is, dependencies that don't
    * correspond to a particular element.
@@ skipping 81 matching lines @@
 
   bool compilationFailed = false;
 
   Compiler(
       {CompilerOptions options,
       api.CompilerOutput outputProvider,
       this.environment: const _EmptyEnvironment(),
       MakeBackendFunction makeBackend,
       MakeReporterFunction makeReporter})
       : this.options = options,
-        this.cacheStrategy = new CacheStrategy(options.hasIncrementalSupport),
         this.userOutputProvider = outputProvider == null
             ? const NullCompilerOutput()
             : outputProvider {
     if (makeReporter != null) {
       _reporter = makeReporter(this, options);
     } else {
       _reporter = new CompilerDiagnosticReporter(this, options);
     }
     _resolution = createResolution();
     _commonElements = new _CompilerCommonElements(_resolution, reporter);
@@ skipping 265 matching lines @@
     StringToken.canonicalizedSubstrings.clear();
     Selector.canonicalizedValues.clear();
 
     // The selector objects held in static fields must remain canonical.
     for (Selector selector in Selectors.ALL) {
       Selector.canonicalizedValues
           .putIfAbsent(selector.hashCode, () => <Selector>[])
           .add(selector);
     }
 
-    assert(uri != null || options.analyzeOnly || options.hasIncrementalSupport);
+    assert(uri != null || options.analyzeOnly);
     return new Future.sync(() {
       if (librariesToAnalyzeWhenRun != null) {
         return Future.forEach(librariesToAnalyzeWhenRun, (libraryUri) {
           reporter.log('Analyzing $libraryUri (${options.buildId})');
           return libraryLoader.loadLibrary(libraryUri);
         });
       }
     }).then((_) {
       if (uri != null) {
         if (options.analyzeOnly) {
@@ skipping 562 matching lines @@
     if (libraryUri.scheme == 'package') {
       int slashPos = libraryUri.path.indexOf('/');
       if (slashPos != -1) {
         String packageName = libraryUri.path.substring(0, slashPos);
         return new Uri(scheme: 'package', path: packageName);
       }
     }
     return libraryUri;
   }
 
-  void forgetElement(Element element) {
-    resolution.forgetElement(element);
-    enqueuer.forgetEntity(element);
-    if (element is MemberElement) {
-      for (Element closure in element.nestedClosures) {
-        // TODO(ahe): It would be nice to reuse names of nested closures.
-        closureToClassMapper.forgetElement(closure);
-      }
-    }
-    backend.forgetElement(element);
-  }
-
   /// Returns [true] if a compile-time error has been reported for element.
   bool elementHasCompileTimeError(Element element) {
     return elementsWithCompileTimeErrors.containsKey(element);
   }
 
   /// Associate [element] with a compile-time error [message].
   void registerCompileTimeError(Element element, DiagnosticMessage message) {
     // The information is only needed if [generateCodeWithCompileTimeErrors].
     if (options.generateCodeWithCompileTimeErrors) {
       if (element == null) {
@@ skipping 819 matching lines @@
 
   @override
   ResolutionWorkItem createWorkItem(Element element) {
     if (_compiler.serialization.isDeserialized(element)) {
       return _compiler.serialization.createResolutionWorkItem(element);
     } else {
       return new ResolutionWorkItem(this, element);
     }
   }
 
-  @override
-  void forgetElement(Element element) {
-    _worldImpactCache.remove(element);
-    _resolutionImpactCache.remove(element);
-  }
-
   ConstantValue _proxyConstant;
 
   @override
   bool isProxyConstant(ConstantValue value) {
     FieldElement field = coreLibrary.find('proxy');
     if (field == null) return false;
     if (!hasBeenResolved(field)) return false;
     if (_proxyConstant == null) {
       _proxyConstant = constants
           .getConstantValue(resolver.constantCompiler.compileConstant(field));
@@ skipping 47 matching lines @@
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }