Remove code supporting incremental compilation in dart2js

pkg/compiler/lib/src/enqueue.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.enqueue;
 
 import 'dart:collection' show Queue;
 
-import 'cache_strategy.dart';
 import 'common/backend_api.dart' show Backend;
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common/work.dart' show WorkItem;
 import 'common.dart';
 import 'compiler.dart' show Compiler, GlobalDependencyRegistry;
 import 'options.dart';
 import 'elements/elements.dart'
     show
         AnalyzableElement,
@@ skipping 24 matching lines @@
       : this.compiler = compiler,
         super(compiler.measurer) {
     _resolution = new ResolutionEnqueuer(
         this,
         compiler.options,
         compiler.resolution,
         compiler.options.analyzeOnly && compiler.options.analyzeMain
             ? const DirectEnqueuerStrategy()
             : const TreeShakingEnqueuerStrategy(),
         compiler.globalDependencies,
-        compiler.backend,
-        compiler.cacheStrategy);
+        compiler.backend);
     _codegen = compiler.backend.createCodegenEnqueuer(this, compiler);
   }
 
   ResolutionEnqueuer get resolution => _resolution;
   Enqueuer get codegen => _codegen;
-
-  void forgetEntity(Entity entity) {
-    resolution.forgetEntity(entity, compiler);
-    codegen.forgetEntity(entity, compiler);
-  }
 }
 
 abstract class Enqueuer {
   WorldBuilder get worldBuilder;
   native.NativeEnqueuer get nativeEnqueuer;
-  void forgetEntity(Entity entity, Compiler compiler);
 
   // TODO(johnniwinther): Initialize [_impactStrategy] to `null`.
   ImpactStrategy _impactStrategy = const ImpactStrategy();
 
   ImpactStrategy get impactStrategy => _impactStrategy;
 
   void open(ImpactStrategy impactStrategy) {
     _impactStrategy = impactStrategy;
   }
 
@@ skipping 59 matching lines @@
 
   /// All declaration elements that have been processed by the resolver.
   final Set<Entity> _processedEntities = new Set<Entity>();
 
   final Queue<WorkItem> _queue = new Queue<WorkItem>();
 
   /// Queue of deferred resolution actions to execute when the resolution queue
   /// has been emptied.
   final Queue<_DeferredAction> _deferredQueue = new Queue<_DeferredAction>();
 
-  ResolutionEnqueuer(
-      this.task,
-      this._options,
-      Resolution resolution,
-      this.strategy,
-      this._globalDependencies,
-      Backend backend,
-      CacheStrategy cacheStrategy,
+  ResolutionEnqueuer(this.task, this._options, Resolution resolution,
+      this.strategy, this._globalDependencies, Backend backend,
       [this.name = 'resolution enqueuer'])
       : this.backend = backend,
         this._resolution = resolution,
         this.nativeEnqueuer = backend.nativeResolutionEnqueuer(),
         _universe = new ResolutionWorldBuilderImpl(
-            backend, resolution, cacheStrategy, const OpenWorldStrategy()),
+            backend, resolution, const OpenWorldStrategy()),
         _workItemBuilder = new ResolutionWorkItemBuilder(resolution) {
     _impactVisitor = new EnqueuerImplImpactVisitor(this);
   }
 
   ResolutionWorldBuilder get worldBuilder => _universe;
 
   bool get queueIsEmpty => _queue.isEmpty;
 
   DiagnosticReporter get _reporter => _resolution.reporter;
 
@@ skipping 236 matching lines @@
   }
 
   void emptyDeferredQueueForTesting() => _emptyDeferredQueue();
 
   void _emptyDeferredQueue() {
     while (!_deferredQueue.isEmpty) {
       _DeferredAction task = _deferredQueue.removeFirst();
       _reporter.withCurrentElement(task.element, task.action);
     }
   }
-
-  void forgetEntity(Entity entity, Compiler compiler) {
-    _universe.forgetEntity(entity, compiler);
-    _processedEntities.remove(entity);
-  }
 }
 
 /// Strategy used by the enqueuer to populate the world.
 class EnqueuerStrategy {
   const EnqueuerStrategy();
 
   /// Process a static use of and element in live code.
   void processStaticUse(EnqueuerImpl enqueuer, StaticUse staticUse) {}
 
   /// Process a type use in live code.
@@ skipping 102 matching lines @@
   @override
   WorkItem createWorkItem(MemberElement element) {
     assert(invariant(element, element.isDeclaration));
     if (element.isMalformed) return null;
 
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     return _resolution.createWorkItem(element);
   }
 }