Remove code supporting incremental compilation in dart2js

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.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 dart2js.js_emitter.full_emitter;
 
 import 'dart:collection' show HashMap;
 import 'dart:convert';
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
@@ skipping 92 matching lines @@
   Map<OutputUnit, List<VariableElement>> outputStaticNonFinalFieldLists;
   Map<OutputUnit, Set<LibraryElement>> outputLibraryLists;
   List<TypedefElement> typedefsNeededForReflection;
 
   final ContainerBuilder containerBuilder = new ContainerBuilder();
   final ClassEmitter classEmitter;
   final NsmEmitter nsmEmitter;
   final InterceptorEmitter interceptorEmitter;
 
   // TODO(johnniwinther): Wrap these fields in a caching strategy.
-  final Set<ConstantValue> cachedEmittedConstants;
   final List<jsAst.Statement> cachedEmittedConstantsAst = <jsAst.Statement>[];
-  final Map<Element, ClassBuilder> cachedClassBuilders;
-  final Set<Element> cachedElements;
 
   bool needsClassSupport = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
 
   /// True if [ContainerBuilder.addMemberMethodFromInfo] used "structured info",
   /// that is, some function was needed for reflection, had stubs, or had a
   /// super alias.
   bool needsStructuredMemberInfo = false;
 
@@ skipping 46 matching lines @@
   // this map.
   final Map<Fragment, Map<Element, ClassBuilder>> elementDescriptors =
       new Map<Fragment, Map<Element, ClassBuilder>>();
 
   final bool generateSourceMap;
 
   Emitter(Compiler compiler, Namer namer, ClosedWorld closedWorld,
       this.generateSourceMap, this.task)
       : this.compiler = compiler,
         this.namer = namer,
-        cachedEmittedConstants = compiler.cacheStrategy.newSet(),
-        cachedClassBuilders = compiler.cacheStrategy.newMap(),
-        cachedElements = compiler.cacheStrategy.newSet(),
         classEmitter = new ClassEmitter(closedWorld),
         interceptorEmitter = new InterceptorEmitter(closedWorld),
         nsmEmitter = new NsmEmitter(closedWorld) {
     constantEmitter = new ConstantEmitter(
         compiler, namer, this.constantReference, constantListGenerator);
     containerBuilder.emitter = this;
     classEmitter.emitter = this;
     nsmEmitter.emitter = this;
     interceptorEmitter.emitter = this;
-    if (compiler.options.hasIncrementalSupport) {
-      // Much like a scout, an incremental compiler is always prepared. For
-      // mixins, classes, and lazy statics, at least.
-      needsClassSupport = true;
-      needsMixinSupport = true;
-      needsLazyInitializer = true;
-      needsStructuredMemberInfo = true;
-    }
   }
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   List<jsAst.Node> cspPrecompiledFunctionFor(OutputUnit outputUnit) {
     return _cspPrecompiledFunctions.putIfAbsent(
         outputUnit, () => new List<jsAst.Node>());
   }
 
   List<jsAst.Expression> cspPrecompiledConstructorNamesFor(
       OutputUnit outputUnit) {
     return _cspPrecompiledConstructorNames.putIfAbsent(
         outputUnit, () => new List<jsAst.Expression>());
   }
 
-  /// Erases the precompiled information for csp mode for all output units.
-  /// Used by the incremental compiler.
-  void clearCspPrecompiledNodes() {
-    _cspPrecompiledFunctions.clear();
-    _cspPrecompiledConstructorNames.clear();
-  }
-
   @override
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant) {
     if (constant.isFunction) return true; // Already emitted.
     if (constant.isPrimitive) return true; // Inlined.
     if (constant.isDummy) return true; // Inlined.
     // The name is null when the constant is already a JS constant.
     // TODO(floitsch): every constant should be registered, so that we can
     // share the ones that take up too much space (like some strings).
     if (namer.constantName(constant) == null) return true;
     return false;
@@ skipping 354 matching lines @@
           });
     } else {
       return js.comment("Constructors are generated at runtime.");
     }
   }
 
   void assembleClass(
       Class cls, ClassBuilder enclosingBuilder, Fragment fragment) {
     ClassElement classElement = cls.element;
     reporter.withCurrentElement(classElement, () {
-      if (compiler.options.hasIncrementalSupport) {
-        ClassBuilder cachedBuilder =
-            cachedClassBuilders.putIfAbsent(classElement, () {
-          ClassBuilder builder = new ClassBuilder.forClass(classElement, namer);
-          classEmitter.emitClass(cls, builder, fragment);
-          return builder;
-        });
-        invariant(classElement, cachedBuilder.fields.isEmpty);
-        invariant(classElement, cachedBuilder.superName == null);
-        invariant(classElement, cachedBuilder.functionType == null);
-        invariant(classElement, cachedBuilder.fieldMetadata == null);
-        enclosingBuilder.properties.addAll(cachedBuilder.properties);
-      } else {
-        classEmitter.emitClass(cls, enclosingBuilder, fragment);
-      }
+      classEmitter.emitClass(cls, enclosingBuilder, fragment);
     });
   }
 
   void assembleStaticFunctions(
       Iterable<Method> staticFunctions, Fragment fragment) {
     if (staticFunctions == null) return;
 
     for (Method method in staticFunctions) {
       MethodElement element = method.element;
       // We need to filter out null-elements for the interceptors.
@@ skipping 110 matching lines @@
       if (!compiler.options.enableMinification) {
         laziesInfo.add(js.quoteName(field.name));
       }
       if (!isMainFragment) {
         laziesInfo.add(js('#', field.holder.name));
       }
     }
     return laziesInfo;
   }
 
-  // TODO(sra): Remove this unused function.
-  jsAst.Expression buildLazilyInitializedStaticField(VariableElement element,
-      {String isolateProperties}) {
-    jsAst.Expression code = backend.generatedCode[element];
-    // The code is null if we ended up not needing the lazily
-    // initialized field after all because of constant folding
-    // before code generation.
-    if (code == null) return null;
-    // The code only computes the initial value. We build the lazy-check
-    // here:
-    //   lazyInitializer(fieldName, getterName, initial, name, prototype);
-    // The name is used for error reporting. The 'initial' must be a
-    // closure that constructs the initial value.
-    if (isolateProperties != null) {
-      // This is currently only used in incremental compilation to patch
-      // in new lazy values.
-      return js('#(#,#,#,#,#)', [
-        js(lazyInitializerName),
-        js.quoteName(namer.globalPropertyName(element)),
-        js.quoteName(namer.lazyInitializerName(element)),
-        code,
-        js.string(element.name),
-        isolateProperties
-      ]);
-    }
-
-    if (compiler.options.enableMinification) {
-      return js('#(#,#,#)', [
-        js(lazyInitializerName),
-        js.quoteName(namer.globalPropertyName(element)),
-        js.quoteName(namer.lazyInitializerName(element)),
-        code
-      ]);
-    } else {
-      return js('#(#,#,#,#)', [
-        js(lazyInitializerName),
-        js.quoteName(namer.globalPropertyName(element)),
-        js.quoteName(namer.lazyInitializerName(element)),
-        code,
-        js.string(element.name)
-      ]);
-    }
-  }
-
   jsAst.Statement buildMetadata(Program program, OutputUnit outputUnit) {
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     jsAst.Expression types = program.metadataTypesForOutputUnit(outputUnit);
 
     if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) {
       jsAst.Expression metadataAccess =
           generateEmbeddedGlobalAccess(embeddedNames.METADATA);
       jsAst.Expression typesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.TYPES);
 
       parts
         ..add(js.statement('# = #;', [metadataAccess, program.metadata]))
         ..add(js.statement('# = #;', [typesAccess, types]));
     } else if (types != null) {
       parts.add(js.statement('var ${namer.deferredTypesName} = #;', types));
     }
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildCompileTimeConstants(List<Constant> constants,
       {bool isMainFragment}) {
     assert(isMainFragment != null);
 
     if (constants.isEmpty) return js.comment("No constants in program.");
     List<jsAst.Statement> parts = <jsAst.Statement>[];
-    if (compiler.options.hasIncrementalSupport && isMainFragment) {
-      parts = cachedEmittedConstantsAst;
-    }
     for (Constant constant in constants) {
       ConstantValue constantValue = constant.value;
-      if (compiler.options.hasIncrementalSupport && isMainFragment) {
-        if (cachedEmittedConstants.contains(constantValue)) continue;
-        cachedEmittedConstants.add(constantValue);
-      }
       parts.add(buildConstantInitializer(constantValue));
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildConstantInitializer(ConstantValue constant) {
     jsAst.Name name = namer.constantName(constant);
     jsAst.Statement initializer = js.statement('#.# = #', [
       namer.globalObjectForConstant(constant),
@@ skipping 177 matching lines @@
             }
           }
           Isolate.prototype = oldIsolate.prototype;
           Isolate.prototype.constructor = Isolate;
           Isolate.#isolatePropertiesName = isolateProperties;
           if (#outputContainsConstantList) {
             Isolate.#makeConstListProperty = oldIsolate.#makeConstListProperty;
           }
           Isolate.#functionThatReturnsNullProperty =
               oldIsolate.#functionThatReturnsNullProperty;
-          if (#hasIncrementalSupport) {
-            Isolate.#lazyInitializerProperty =
-                oldIsolate.#lazyInitializerProperty;
-          }
           return Isolate;
       }
 
       }''',
         {
           'allClasses': allClassesAccess,
           'getTypeFromName': getTypeFromNameAccess,
           'interceptorsByTag': interceptorsByTagAccess,
           'leafTags': leafTagsAccess,
           'finishedClasses': finishedClassesAccess,
           'needsLazyInitializer': needsLazyInitializer,
           'lazies': laziesAccess,
           'cyclicThrow': cyclicThrow,
           'isolatePropertiesName': namer.isolatePropertiesName,
           'outputContainsConstantList': outputContainsConstantList,
           'makeConstListProperty': makeConstListProperty,
           'functionThatReturnsNullProperty':
               backend.rtiEncoder.getFunctionThatReturnsNullName,
-          'hasIncrementalSupport': compiler.options.hasIncrementalSupport,
-          'lazyInitializerProperty': lazyInitializerProperty,
         });
   }
 
   jsAst.Statement buildConvertToFastObjectFunction() {
     List<jsAst.Statement> debugCode = <jsAst.Statement>[];
     if (DEBUG_FAST_OBJECTS) {
       debugCode.add(js.statement(r'''
         // The following only works on V8 when run with option
         // "--allow-natives-syntax".  We use'new Function' because the
          // miniparser does not understand V8 native syntax.
@@ skipping 27 matching lines @@
       // mode.
       properties.__MAGIC_SLOW_PROPERTY = 1;
       delete properties.__MAGIC_SLOW_PROPERTY;
       return properties;
     }''');
   }
 
   jsAst.Statement buildSupportsDirectProtoAccess() {
     jsAst.Statement supportsDirectProtoAccess;
 
-    if (compiler.options.hasIncrementalSupport) {
-      supportsDirectProtoAccess = js.statement(r'''
-        var supportsDirectProtoAccess = false;
-      ''');
-    } else {
-      supportsDirectProtoAccess = js.statement(r'''
-        var supportsDirectProtoAccess = (function () {
-          var cls = function () {};
-          cls.prototype = {'p': {}};
-          var object = new cls();
-          if (!(object.__proto__ && object.__proto__.p === cls.prototype.p))
-            return false;
-    
-          try {
-            // Are we running on a platform where the performance is good?
-            // (i.e. Chrome or d8).
+    supportsDirectProtoAccess = js.statement(r'''
+      var supportsDirectProtoAccess = (function () {
+        var cls = function () {};
+        cls.prototype = {'p': {}};
+        var object = new cls();
+        if (!(object.__proto__ && object.__proto__.p === cls.prototype.p))
+          return false;
 
-            // Chrome userAgent?
-            if (typeof navigator != "undefined" &&
-                typeof navigator.userAgent == "string" &&
-                navigator.userAgent.indexOf("Chrome/") >= 0) return true;
+        try {
+          // Are we running on a platform where the performance is good?
+          // (i.e. Chrome or d8).
 
-            // d8 version() looks like "N.N.N.N", jsshell version() like "N".
-            if (typeof version == "function" &&
-                version.length == 0) {
-              var v = version();
-              if (/^\d+\.\d+\.\d+\.\d+$/.test(v)) return true;
-            }
-          } catch(_) {}
-          
-          return false;
-        })();
-      ''');
-    }
+          // Chrome userAgent?
+          if (typeof navigator != "undefined" &&
+              typeof navigator.userAgent == "string" &&
+              navigator.userAgent.indexOf("Chrome/") >= 0) return true;
+
+          // d8 version() looks like "N.N.N.N", jsshell version() like "N".
+          if (typeof version == "function" &&
+              version.length == 0) {
+            var v = version();
+            if (/^\d+\.\d+\.\d+\.\d+$/.test(v)) return true;
+          }
+        } catch(_) {}
+
+        return false;
+      })();
+    ''');
 
     return supportsDirectProtoAccess;
   }
 
   jsAst.Expression generateLibraryDescriptor(
       LibraryElement library, Fragment fragment) {
     var uri = "";
     if (!compiler.options.enableMinification || backend.mustPreserveUris) {
       uri = library.canonicalUri;
       if (uri.scheme == 'file' && compiler.options.outputUri != null) {
@@ skipping 237 matching lines @@
       jsAst.Expression mangledGlobalNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_GLOBAL_NAMES);
       jsAst.ObjectInitializer map = new jsAst.ObjectInitializer(properties);
       parts.add(js.statement('# = #', [mangledGlobalNamesAccess, map]));
     }
 
     return new jsAst.Block(parts);
   }
 
   void checkEverythingEmitted(Iterable<Element> elements) {
-    List<Element> pendingStatics;
-    if (!compiler.options.hasIncrementalSupport) {
-      pendingStatics =
-          Elements.sortedByPosition(elements.where((e) => !e.isLibrary));
+    List<Element> pendingStatics =
+        Elements.sortedByPosition(elements.where((e) => !e.isLibrary));
 
-      pendingStatics.forEach((element) => reporter.reportInfo(
-          element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
-    }
+    pendingStatics.forEach((element) => reporter.reportInfo(
+        element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
 
     if (pendingStatics != null && !pendingStatics.isEmpty) {
       reporter.internalError(
           pendingStatics.first, 'Pending statics (see above).');
     }
   }
 
   void assembleLibrary(Library library, Fragment fragment) {
     LibraryElement libraryElement = library.element;
 
@@ skipping 58 matching lines @@
     }
 
     if (descriptors.isNotEmpty) {
       List<Element> remainingLibraries =
           descriptors.keys.where((Element e) => e is LibraryElement).toList();
 
       // The remaining descriptors are only accessible through reflection.
       // The program builder does not collect libraries that only
       // contain typedefs that are used for reflection.
       for (LibraryElement element in remainingLibraries) {
-        assert(element is LibraryElement ||
-            compiler.options.hasIncrementalSupport);
+        assert(element is LibraryElement);
         if (element is LibraryElement) {
           parts.add(generateLibraryDescriptor(element, mainFragment));
           descriptors.remove(element);
         }
       }
     }
     jsAst.ArrayInitializer descriptorsAst = new jsAst.ArrayInitializer(parts);
 
     // Using a named function here produces easier to read stack traces in
     // Chrome/V8.
     statements.add(js.statement(
         """
     (function() {
        // No renaming in the top-level function to save the locals for the
        // nested context where they will be used more. We have to put the
        // comment into a hole as the parser strips out comments right away.
        #disableVariableRenaming;
        #supportsDirectProtoAccess;
 
-       if (#hasIncrementalSupport) {
-         #helper = #helper || Object.create(null);
-         #helper.patch = function(a) { eval(a)};
-         #helper.schemaChange = #schemaChange;
-         #helper.addMethod = #addMethod;
-         #helper.extractStubs =
-           function(array, name, isStatic, originalDescriptor) {
-             var descriptor = Object.create(null);
-             this.addStubs(descriptor, array, name, isStatic, []);
-             return descriptor;
-            };
-       }
-
        if (#isProgramSplit) {
          /// We collect all the global state, so it can be passed to the
          /// initializer of deferred files.
          var #globalsHolder = Object.create(null)
        }
 
        // [map] returns an object that V8 shouldn't try to optimize with a
        // hidden class. This prevents a potential performance problem where V8
        // tries to build a hidden class for an object used as a hashMap.
        // It requires fewer characters to declare a variable as a parameter than
@@ skipping 72 matching lines @@
        #convertGlobalObjectsToFastObjects;
        #debugFastObjects;
 
        #init;
 
        #main;
     })();
     """,
         {
           "disableVariableRenaming": js.comment("/* ::norenaming:: */"),
-          "hasIncrementalSupport": compiler.options.hasIncrementalSupport,
-          "helper": js('this.#', [namer.incrementalHelperName]),
-          "schemaChange": buildSchemaChangeFunction(),
-          "addMethod": buildIncrementalAddMethod(),
           "isProgramSplit": isProgramSplit,
           "supportsDirectProtoAccess": buildSupportsDirectProtoAccess(),
           "globalsHolder": globalsHolder,
           "globalObjectSetup": buildGlobalObjectSetup(isProgramSplit),
           "isolateName": namer.isolateName,
           "isolatePropertiesName": js(isolatePropertiesName),
           "initName": initName,
           "functionThatReturnsNull": buildFunctionThatReturnsNull(),
           "mangledNames": buildMangledNames(),
           "setupProgram":
@@ skipping 55 matching lines @@
     }
 
     mainOutput.close();
 
     if (generateSourceMap) {
       outputSourceMap(mainOutput, lineColumnCollector, '',
           compiler.options.sourceMapUri, compiler.options.outputUri);
     }
   }
 
-  /// Used by incremental compilation to patch up the prototype of
-  /// [oldConstructor] for use as prototype of [newConstructor].
-  jsAst.Fun buildSchemaChangeFunction() {
-    if (!compiler.options.hasIncrementalSupport) return null;
-    return js('''
-function(newConstructor, oldConstructor, superclass) {
-  // Invariant: newConstructor.prototype has no interesting properties besides
-  // generated accessors. These are copied to oldPrototype which will be
-  // updated by other incremental changes.
-  if (superclass != null) {
-    this.inheritFrom(newConstructor, superclass);
-  }
-  var oldPrototype = oldConstructor.prototype;
-  var newPrototype = newConstructor.prototype;
-  var hasOwnProperty = Object.prototype.hasOwnProperty;
-  for (var property in newPrototype) {
-    if (hasOwnProperty.call(newPrototype, property)) {
-      // Copy generated accessors.
-      oldPrototype[property] = newPrototype[property];
-    }
-  }
-  oldPrototype.__proto__ = newConstructor.prototype.__proto__;
-  oldPrototype.constructor = newConstructor;
-  newConstructor.prototype = oldPrototype;
-  return newConstructor;
-}''');
-  }
-
-  /// Used by incremental compilation to patch up an object ([holder]) with a
-  /// new (or updated) method.  [arrayOrFunction] is either the new method, or
-  /// an array containing the method (see
-  /// [ContainerBuilder.addMemberMethodFromInfo]). [name] is the name of the
-  /// new method. [isStatic] tells if method is static (or
-  /// top-level). [globalFunctionsAccess] is a reference to
-  /// [embeddedNames.GLOBAL_FUNCTIONS].
-  jsAst.Fun buildIncrementalAddMethod() {
-    if (!compiler.options.hasIncrementalSupport) return null;
-    return js(r"""
-function(originalDescriptor, name, holder, isStatic, globalFunctionsAccess) {
-  var arrayOrFunction = originalDescriptor[name];
-  var method;
-  if (arrayOrFunction.constructor === Array) {
-    var existing = holder[name];
-    var array = arrayOrFunction;
-
-    // Each method may have a number of stubs associated. For example, if an
-    // instance method supports multiple arguments, a stub for each matching
-    // selector. There is also a getter stub for tear-off getters. For example,
-    // an instance method foo([a]) may have the following stubs: foo$0, foo$1,
-    // and get$foo (here exemplified using unminified names).
-    // [extractStubs] returns a JavaScript object whose own properties
-    // corresponds to the stubs.
-    var descriptor =
-        this.extractStubs(array, name, isStatic, originalDescriptor);
-    method = descriptor[name];
-
-    // Iterate through the properties of descriptor and copy the stubs to the
-    // existing holder (for instance methods, a prototype).
-    for (var property in descriptor) {
-      if (!Object.prototype.hasOwnProperty.call(descriptor, property)) continue;
-      var stub = descriptor[property];
-      var existingStub = holder[property];
-      if (stub === method || !existingStub || !stub.$getterStub) {
-        // Not replacing an existing getter stub.
-        holder[property] = stub;
-        continue;
-      }
-      if (!stub.$getterStub) {
-        var error = new Error('Unexpected stub.');
-        error.stub = stub;
-        throw error;
-      }
-
-      // Existing getter stubs need special treatment as they may already have
-      // been called and produced a closure.
-      this.pendingStubs = this.pendingStubs || [];
-      // It isn't safe to invoke the stub yet.
-      this.pendingStubs.push((function(holder, stub, existingStub, existing,
-                                       method) {
-        return function() {
-          var receiver = isStatic ? holder : new holder.constructor();
-          // Invoke the existing stub to obtain the tear-off closure.
-          existingStub = existingStub.call(receiver);
-          // Invoke the new stub to create a tear-off closure we can use as a
-          // prototype.
-          stub = stub.call(receiver);
-
-          // Copy the properties from the new tear-off's prototype to the
-          // prototype of the existing tear-off.
-          var newProto = stub.constructor.prototype;
-          var existingProto = existingStub.constructor.prototype;
-          for (var stubProperty in newProto) {
-            if (!Object.prototype.hasOwnProperty.call(newProto, stubProperty))
-              continue;
-            existingProto[stubProperty] = newProto[stubProperty];
-          }
-
-          // Update all the existing stub's references to [existing] to
-          // [method]. Instance tear-offs are call-by-name, so this isn't
-          // necessary for those.
-          if (!isStatic) return;
-          for (var reference in existingStub) {
-            if (existingStub[reference] === existing) {
-              existingStub[reference] = method;
-            }
-          }
-        }
-      })(holder, stub, existingStub, existing, method));
-    }
-  } else {
-    method = arrayOrFunction;
-    holder[name] = method;
-  }
-  if (isStatic) globalFunctionsAccess[name] = method;
-}""");
-  }
-
   Map<OutputUnit, jsAst.Expression> buildDescriptorsForOutputUnits(
       Program program) {
     Map<OutputUnit, jsAst.Expression> outputs =
         new Map<OutputUnit, jsAst.Expression>();
 
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
 
       Map<Element, ClassBuilder> descriptors = elementDescriptors[fragment];
 
@@ skipping 371 matching lines @@
     // Json does not support comments, so we embed the explanation in the
     // data.
     mapping["_comment"] = "This mapping shows which compiled `.js` files are "
         "needed for a given deferred library import.";
     mapping.addAll(compiler.deferredLoadTask.computeDeferredMap());
     compiler.outputProvider(
         compiler.options.deferredMapUri.path, 'deferred_map')
       ..add(const JsonEncoder.withIndent("  ").convert(mapping))
       ..close();
   }
-
-  void invalidateCaches() {
-    if (!compiler.options.hasIncrementalSupport) return;
-    if (cachedElements.isEmpty) return;
-    for (Element element in backend.codegenEnqueuer.newlyEnqueuedElements) {
-      if (element.isInstanceMember) {
-        cachedClassBuilders.remove(element.enclosingClass);
-      }
-    }
-  }
 }