Remove code supporting incremental compilation in dart2js

pkg/compiler/lib/src/js_emitter/metadata_collector.dart

 // Copyright (c) 2013, 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.metadata_collector;
 
 import 'package:js_ast/src/precedence.dart' as js_precedence;
 
 import '../common.dart';
 import '../compiler.dart' show Compiler;
@@ skipping 98 matching lines @@
   bind(_MetadataEntry entry) {
     assert(!isBound);
     _forwardTo = entry;
   }
 }
 
 class _MetadataList extends jsAst.DeferredExpression {
   jsAst.Expression _value;
 
   void setExpression(jsAst.Expression value) {
-    // TODO(herhut): Enable the below assertion once incremental mode is gone.
-    // assert(_value == null);
+    assert(_value == null);
     assert(value.precedenceLevel == this.precedenceLevel);
     _value = value;
   }
 
   jsAst.Expression get value {
     assert(_value != null);
     return _value;
   }
 
   int get precedenceLevel => js_precedence.PRIMARY;
@@ skipping 18 matching lines @@
       new Map<OutputUnit, _MetadataList>();
 
   jsAst.Expression getTypesForOutputUnit(OutputUnit outputUnit) {
     return _typesTokens.putIfAbsent(outputUnit, () => new _MetadataList());
   }
 
   /// A map used to canonicalize the entries of types.
   Map<OutputUnit, Map<ResolutionDartType, _BoundMetadataEntry>> _typesMap =
       <OutputUnit, Map<ResolutionDartType, _BoundMetadataEntry>>{};
 
-  // To support incremental compilation, we have to be able to eagerly emit
-  // metadata and add metadata later on. We use the below two counters for
-  // this.
-  int _globalMetadataCounter = 0;
-  int _globalTypesCounter = 0;
-
   MetadataCollector(this._compiler, this._emitter) {
     _globalMetadataMap = new Map<String, _BoundMetadataEntry>();
   }
 
   JavaScriptBackend get _backend => _compiler.backend;
   TypeVariableHandler get _typeVariableHandler => _backend.typeVariableHandler;
   DiagnosticReporter get reporter => _compiler.reporter;
 
   bool _mustEmitMetadataFor(Element element) {
     return _backend.mustRetainMetadata &&
@@ skipping 138 matching lines @@
 
   Placeholder getMetadataPlaceholder([debug]) {
     return new _ForwardingMetadataEntry(debug);
   }
 
   _MetadataEntry _addGlobalMetadata(jsAst.Node node) {
     String nameToKey(jsAst.Name name) => "${name.key}";
     String printed =
         jsAst.prettyPrint(node, _compiler, renamerForNames: nameToKey);
     return _globalMetadataMap.putIfAbsent(printed, () {
-      _BoundMetadataEntry result = new _BoundMetadataEntry(node);
-      if (_compiler.options.hasIncrementalSupport) {
-        result.finalize(_globalMetadataCounter++);
-      }
-      return result;
+      return new _BoundMetadataEntry(node);
     });
   }
 
   jsAst.Expression _computeTypeRepresentation(ResolutionDartType type,
       {ignoreTypeVariables: false}) {
     jsAst.Expression representation =
         _backend.rtiEncoder.getTypeRepresentation(type, (variable) {
       if (ignoreTypeVariables) return new jsAst.LiteralNull();
       return _typeVariableHandler.reifyTypeVariable(variable.element);
     }, (ResolutionTypedefType typedef) {
@@ skipping 11 matching lines @@
   }
 
   jsAst.Expression addTypeInOutputUnit(
       ResolutionDartType type, OutputUnit outputUnit,
       {ignoreTypeVariables: false}) {
     if (_typesMap[outputUnit] == null) {
       _typesMap[outputUnit] =
           new Map<ResolutionDartType, _BoundMetadataEntry>();
     }
     return _typesMap[outputUnit].putIfAbsent(type, () {
-      _BoundMetadataEntry result = new _BoundMetadataEntry(
-          _computeTypeRepresentation(type,
-              ignoreTypeVariables: ignoreTypeVariables));
-      if (_compiler.options.hasIncrementalSupport) {
-        result.finalize(_globalTypesCounter++);
-      }
-      return result;
+      return new _BoundMetadataEntry(_computeTypeRepresentation(type,
+          ignoreTypeVariables: ignoreTypeVariables));
     });
   }
 
   List<jsAst.DeferredNumber> computeMetadata(FunctionElement element) {
     return reporter.withCurrentElement(element, () {
       if (!_mustEmitMetadataFor(element)) return const <jsAst.DeferredNumber>[];
       List<jsAst.DeferredNumber> metadata = <jsAst.DeferredNumber>[];
       for (MetadataAnnotation annotation in element.metadata) {
         metadata.add(reifyMetadata(annotation));
       }
@@ skipping 16 matching lines @@
 
     void countTokensInTypes(Iterable<_BoundMetadataEntry> entries) {
       jsAst.TokenCounter counter = new jsAst.TokenCounter();
       entries
           .where((_BoundMetadataEntry e) => e._rc > 0)
           .map((_BoundMetadataEntry e) => e.entry)
           .forEach(counter.countTokens);
     }
 
     jsAst.ArrayInitializer finalizeMap(Map<dynamic, _BoundMetadataEntry> map) {
-      // When in incremental mode, we allocate entries eagerly.
-      if (_compiler.options.hasIncrementalSupport) {
-        return new jsAst.ArrayInitializer(map.values.toList());
-      }
-
       bool isUsed(_BoundMetadataEntry entry) => entry.isUsed;
       List<_BoundMetadataEntry> entries = map.values.where(isUsed).toList();
       entries.sort();
 
       // TODO(herhut): Bucket entries by index length and use a stable
       //               distribution within buckets.
       int count = 0;
       for (_BoundMetadataEntry entry in entries) {
         entry.finalize(count++);
       }
@@ skipping 30 matching lines @@
     if (token is _ForwardingMetadataEntry && !token.isBound) {
       _foundUnboundToken = true;
     }
   }
 
   bool findUnboundPlaceholders(jsAst.Node node) {
     node.accept(this);
     return _foundUnboundToken;
   }
 }