Remove code supporting incremental compilation in dart2js

pkg/compiler/lib/src/js_backend/backend.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 js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 443 matching lines @@
 
   /// True if the html library has been loaded.
   bool htmlLibraryIsLoaded = false;
 
   /// True when we enqueue the loadLibrary code.
   bool isLoadLibraryFunctionResolved = false;
 
   /// `true` if access to [BackendHelpers.invokeOnMethod] is supported.
   bool hasInvokeOnSupport = false;
 
-  /// `true` if tear-offs are supported for incremental compilation.
-  bool hasIncrementalTearOffSupport = false;
-
   /// `true` of `Object.runtimeType` is supported.
   bool hasRuntimeTypeSupport = false;
 
   /// `true` of use of the `dart:isolate` library is supported.
   bool hasIsolateSupport = false;
 
   /// `true` of `Function.apply` is supported.
   bool hasFunctionApplySupport = false;
 
   /// List of constants from metadata.  If metadata must be preserved,
@@ skipping 279 matching lines @@
   }
 
   /**
    * Record that [method] is called from a subclass via `super`.
    */
   bool maybeRegisterAliasedSuperMember(
       MemberElement member, Selector selector) {
     if (!canUseAliasedSuperMember(member, selector)) {
       // Invoking a super getter isn't supported, this would require changes to
       // compact field descriptors in the emitter.
-      // We also turn off this optimization in incremental compilation, to
-      // avoid having to regenerate a method just because someone started
-      // calling it through super.
       return false;
     }
     aliasedSuperMembers.add(member);
     return true;
   }
 
   bool canUseAliasedSuperMember(Element member, Selector selector) {
-    return !selector.isGetter && !compiler.options.hasIncrementalSupport;
+    return !selector.isGetter;
   }
 
   /**
    * Returns `true` if [member] is called from a subclass via `super`.
    */
   bool isAliasedSuperMember(FunctionElement member) {
     return aliasedSuperMembers.contains(member);
   }
 
   /// Returns `true` if [element] is part of JsInterop.
@@ skipping 651 matching lines @@
   bool isComplexNoSuchMethod(FunctionElement element) =>
       noSuchMethodRegistry.isComplex(element);
 
   bool methodNeedsRti(FunctionElement function) {
     return rti.methodsNeedingRti.contains(function) || hasRuntimeTypeSupport;
   }
 
   CodegenEnqueuer get codegenEnqueuer => compiler.enqueuer.codegen;
 
   CodegenEnqueuer createCodegenEnqueuer(CompilerTask task, Compiler compiler) {
-    return new CodegenEnqueuer(task, compiler.cacheStrategy, this,
-        compiler.options, const TreeShakingEnqueuerStrategy());
+    return new CodegenEnqueuer(
+        task, this, compiler.options, const TreeShakingEnqueuerStrategy());
   }
 
   WorldImpact codegen(CodegenWorkItem work) {
     Element element = work.element;
     if (compiler.elementHasCompileTimeError(element)) {
       DiagnosticMessage message =
           // If there's more than one error, the first is probably most
           // informative, as the following errors may be side-effects of the
           // first error.
           compiler.elementsWithCompileTimeErrors[element].first;
@@ skipping 823 matching lines @@
         _noSuchMethodEnabledForCodegen = true;
       }
     }
 
     if (!enqueuer.queueIsEmpty) return false;
 
     if (compiler.options.useKernel && compiler.mainApp != null) {
       kernelTask.buildKernelIr();
     }
 
-    if (compiler.options.hasIncrementalSupport &&
-        !hasIncrementalTearOffSupport) {
-      // Always enable tear-off closures during incremental compilation.
-      Element element = helpers.closureFromTearOff;
-      if (element != null) {
-        enqueuer.applyImpact(
-            impactTransformer.createImpactFor(impacts.closureClass));
-      }
-      hasIncrementalTearOffSupport = true;
-    }
-
     if (!enqueuer.isResolutionQueue && preMirrorsMethodCount == 0) {
       preMirrorsMethodCount = generatedCode.length;
     }
 
     if (isTreeShakingDisabled) {
       enqueuer.applyImpact(mirrorsAnalysis.computeImpactForReflectiveElements(
           recentClasses,
           enqueuer.processedClasses,
           compiler.libraryLoader.libraries,
           forResolution: enqueuer.isResolutionQueue));
@@ skipping 199 matching lines @@
           "@NoSideEffects() should always be combined with @NoInline.");
     }
   }
 
   FunctionElement helperForBadMain() => helpers.badMain;
 
   FunctionElement helperForMissingMain() => helpers.missingMain;
 
   FunctionElement helperForMainArity() => helpers.mainHasTooManyParameters;
 
-  void forgetElement(Element element) {
-    constants.forgetElement(element);
-    constantCompilerTask.dartConstantCompiler.forgetElement(element);
-    aliasedSuperMembers.remove(element);
-    generatedCode.remove(element);
-    if (element is MemberElement) {
-      for (Element closure in element.nestedClosures) {
-        generatedCode.remove(closure);
-      }
-    }
-  }
-
   @override
   WorldImpact computeMainImpact(MethodElement mainMethod,
       {bool forResolution}) {
     WorldImpactBuilderImpl mainImpact = new WorldImpactBuilderImpl();
     if (mainMethod.parameters.isNotEmpty) {
       impactTransformer.registerBackendImpact(
           mainImpact, impacts.mainWithArguments);
       mainImpact.registerStaticUse(
           new StaticUse.staticInvoke(mainMethod, CallStructure.TWO_ARGS));
       // If the main method takes arguments, this compilation could be the
@@ skipping 761 matching lines @@
   @override
   bool isNativeClass(ClassElement element) {
     return helpers.backend.isNative(element);
   }
 
   @override
   bool isNativeMember(MemberElement element) {
     return helpers.backend.isNative(element);
   }
 }