Remove code supporting incremental compilation in dart2js

pkg/compiler/lib/src/universe/world_builder.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 universe;
 
 import 'dart:collection';
 
-import '../cache_strategy.dart';
 import '../common.dart';
 import '../common/backend_api.dart' show Backend;
 import '../common/names.dart' show Identifiers;
 import '../common/resolution.dart' show Resolution;
-import '../compiler.dart' show Compiler;
 import '../core_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../universe/class_set.dart';
 import '../universe/function_set.dart' show FunctionSetBuilder;
 import '../util/enumset.dart';
 import '../util/util.dart';
 import '../world.dart' show World, ClosedWorld, ClosedWorldImpl, OpenWorld;
@@ skipping 448 matching lines @@
 
   final Map<ClassElement, Set<MixinApplicationElement>> _mixinUses =
       new Map<ClassElement, Set<MixinApplicationElement>>();
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   final Map<ClassElement, ClassHierarchyNode> _classHierarchyNodes =
       <ClassElement, ClassHierarchyNode>{};
   final Map<ClassElement, ClassSet> _classSets = <ClassElement, ClassSet>{};
 
-  final Set<Element> alreadyPopulated;
-
-  final CacheStrategy cacheStrategy;
-
   bool get isClosed => _closed;
 
-  ResolutionWorldBuilderImpl(Backend backend, Resolution resolution,
-      CacheStrategy cacheStrategy, this.selectorConstraintsStrategy)
+  ResolutionWorldBuilderImpl(
+      Backend backend, Resolution resolution, this.selectorConstraintsStrategy)
       : this._backend = backend,
-        this._resolution = resolution,
-        this.cacheStrategy = cacheStrategy,
-        alreadyPopulated = cacheStrategy.newSet() {
+        this._resolution = resolution {
     _allFunctions = new FunctionSetBuilder();
   }
 
   Iterable<ClassElement> get processedClasses => _processedClasses.keys
       .where((cls) => _processedClasses[cls].isInstantiated);
 
   CommonElements get commonElements => _resolution.commonElements;
 
   ClosedWorld get closedWorldForTesting {
     if (!_closed) {
@@ skipping 285 matching lines @@
       case StaticUseKind.DIRECT_INVOKE:
         invariant(
             element, 'Direct static use is not supported for resolution.');
         break;
     }
     if (useSet.isNotEmpty) {
       memberUsed(usage.entity, useSet);
     }
   }
 
-  void forgetEntity(Entity entity, Compiler compiler) {
-    allClosures.remove(entity);
-    slowDirectlyNestedClosures(entity).forEach(compiler.forgetElement);
-    closurizedMembers.remove(entity);
-    fieldSetters.remove(entity);
-    _instantiationInfo.remove(entity);
-
-    void removeUsage(Set<_MemberUsage> set, Entity entity) {
-      if (set == null) return;
-      set.removeAll(
-          set.where((_MemberUsage usage) => usage.entity == entity).toList());
-    }
-
-    _processedClasses.remove(entity);
-    removeUsage(_instanceMembersByName[entity.name], entity);
-    removeUsage(_instanceFunctionsByName[entity.name], entity);
-  }
-
   // TODO(ahe): Replace this method with something that is O(1), for example,
   // by using a map.
   List<LocalFunctionElement> slowDirectlyNestedClosures(Element element) {
     // Return new list to guard against concurrent modifications.
     return new List<LocalFunctionElement>.from(
         allClosures.where((LocalFunctionElement closure) {
       return closure.executableContext == element;
     }));
   }
 
@@ skipping 199 matching lines @@
     Map<ClassElement, Set<ClassElement>> typesImplementedBySubclasses =
         new Map<ClassElement, Set<ClassElement>>();
 
     /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
     /// properties of the [ClassHierarchyNode] for [cls].
 
     void addSubtypes(ClassElement cls, InstantiationInfo info) {
       if (!info.hasInstantiation) {
         return;
       }
-      if (cacheStrategy.hasIncrementalSupport && !alreadyPopulated.add(cls)) {
-        return;
-      }
       assert(cls.isDeclaration);
       if (!cls.isResolved) {
         reporter.internalError(cls, 'Class "${cls.name}" is not resolved.');
       }
 
       _updateClassHierarchyNodeForClass(cls,
           directlyInstantiated: info.isDirectlyInstantiated,
           abstractlyInstantiated: info.isAbstractlyInstantiated);
 
       // Walk through the superclasses, and record the types
@@ skipping 448 matching lines @@
             _getMemberUsage(staticUse.element, memberUsed);
         memberUsed(instanceUsage.entity, instanceUsage.invoke());
         _instanceMembersByName[instanceUsage.entity.name]
             ?.remove(instanceUsage);
         useSet.addAll(usage.normalUse());
         break;
     }
     memberUsed(usage.entity, useSet);
   }
 
-  void forgetElement(Element element, Compiler compiler) {
-    _processedClasses.remove(element);
-    _directlyInstantiatedClasses.remove(element);
-    if (element is ClassElement) {
-      assert(invariant(element, element.thisType.isRaw,
-          message: 'Generic classes not supported (${element.thisType}).'));
-      _instantiatedTypes..remove(element.rawType)..remove(element.thisType);
-    }
-    removeFromSet(_instanceMembersByName, element);
-    removeFromSet(_instanceFunctionsByName, element);
-    if (element is MemberElement) {
-      for (Element closure in element.nestedClosures) {
-        removeFromSet(_instanceMembersByName, closure);
-        removeFromSet(_instanceFunctionsByName, closure);
-      }
-    }
-  }
-
   void processClassMembers(ClassElement cls, MemberUsedCallback memberUsed) {
     cls.implementation.forEachMember((_, MemberElement member) {
       assert(invariant(member, member.isDeclaration));
       if (!member.isInstanceMember) return;
       _getMemberUsage(member, memberUsed);
     });
   }
 
   _MemberUsage _getMemberUsage(
       MemberElement member, MemberUsedCallback memberUsed) {
@@ skipping 439 matching lines @@
     if (hasClosurization) {
       return MemberUses.NONE;
     }
     hasNormalUse = hasClosurization = true;
     return _pendingUse.removeAll(MemberUses.ALL_STATIC);
   }
 
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }
-
-void removeFromSet(Map<String, Set<_MemberUsage>> map, Element element) {
-  Set<_MemberUsage> set = map[element.name];
-  if (set == null) return;
-  set.removeAll(
-      set.where((_MemberUsage usage) => usage.entity == element).toList());
-}