Revert "dart2js: Destroy some type inference graph edges after type inference."

pkg/compiler/lib/src/inferrer/type_graph_nodes.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 compiler.src.inferrer.type_graph_nodes;
 
 import 'dart:collection' show IterableBase;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 219 matching lines @@
     _assignments = STOP_TRACKING_ASSIGNMENTS_MARKER;
     abandonInferencing = true;
     isStable = true;
   }
 
   void maybeResume() {
     if (!mightResume) return;
     abandonInferencing = false;
     doNotEnqueue = false;
   }
-
-  /// Destroys information not needed after type inference.
-  void cleanup() {
-    users = null;
-    _assignments = null;
-  }
 }
 
 abstract class ApplyableTypeInformation implements TypeInformation {
   bool mightBePassedToFunctionApply = false;
 }
 
 /**
  * Marker node used only during tree construction but not during actual type
  * refinement.
  *
@@ skipping 128 matching lines @@
 class MemberTypeInformation extends ElementTypeInformation
     with ApplyableTypeInformation {
   TypedElement get element => super.element;
 
   /**
    * If [element] is a function, [closurizedCount] is the number of
    * times it is closurized. The value gets updated while infering.
    */
   int closurizedCount = 0;
 
-  // Strict `bool` value is computed in cleanup(). Also used as a flag to see if
-  // cleanup has been called.
-  bool _isCalledOnce = null;
-
   /**
    * This map contains the callers of [element]. It stores all unique call sites
    * to enable counting the global number of call sites of [element].
    *
    * A call site is either an AST [ast.Node], a [cps_ir.Node] or in the case of
    * synthesized calls, an [Element] (see uses of [synthesizeForwardingCall]
    * in [SimpleTypeInferrerVisitor]).
-   *
-   * The global information is summarized in [cleanup], after which [_callers]
-   * is set to `null`.
    */
-  Map<Element, Setlet<Spannable>> _callers;
+  final Map<Element, Setlet<Spannable>> _callers = new Map<Element, Setlet>();
 
   MemberTypeInformation._internal(Element element)
       : super._internal(null, element);
 
   void addCall(Element caller, Spannable node) {
     assert(node is ast.Node || node is cps_ir.Node || node is Element);
-    _callers ??= <Element, Setlet>{};
     _callers.putIfAbsent(caller, () => new Setlet()).add(node);
   }
 
   void removeCall(Element caller, node) {
-    if (_callers == null) return;
     Setlet calls = _callers[caller];
     if (calls == null) return;
     calls.remove(node);
     if (calls.isEmpty) {
       _callers.remove(caller);
     }
   }
 
-  Iterable<Element> get callers {
-    // TODO(sra): This is called only from an unused API. If it becomes used,
-    // [cleanup] will need to copy `_caller.keys`.
-    assert(false); // Unused.
-    return _callers.keys;
-  }
+  Iterable<Element> get callers => _callers.keys;
 
   bool isCalledOnce() {
-    assert(_isCalledOnce != null);
-    return _isCalledOnce;
-  }
-
-  bool _computeIsCalledOnce() {
-    if (_callers == null) return false;
     int count = 0;
     for (var set in _callers.values) {
       count += set.length;
       if (count > 1) return false;
     }
     return count == 1;
   }
 
   bool get isClosurized => closurizedCount > 0;
 
@@ skipping 95 matching lines @@
     // The number of assignments of non-final fields is
     // not stable. Therefore such a field cannot be stable.
     if (element.isField && !(element.isConst || element.isFinal)) {
       return false;
     }
 
     if (element.isFunction) return false;
 
     return super.hasStableType(inferrer);
   }
-
-  void cleanup() {
-    if (_isCalledOnce != null) return;
-    _isCalledOnce = _computeIsCalledOnce();
-    _callers = null;
-    super.cleanup();
-  }
 }
 
 /**
  * A node representing parameters:
  *
  * - Parameters
  * - Initializing formals
  *
  * These should never be created directly but instead are constructed by
  * the [ElementTypeInformation] factory.
@@ skipping 769 matching lines @@
       return new ContainerTypeMask(originalType.forwardTo,
                                    originalType.allocationNode,
                                    originalType.allocationElement,
                                    elementType.type,
                                    inferredLength);
     }
     return mask;
   }
 
   TypeMask safeType(TypeGraphInferrerEngine inferrer) => originalType;
-
-  void cleanup() {
-    super.cleanup();
-    elementType.cleanup();
-    _flowsInto = null;
-  }
 }
 
 /**
  * An [ElementInContainerTypeInformation] holds the common type of the
  * elements in a [ListTypeInformation].
  */
 class ElementInContainerTypeInformation extends InferredTypeInformation {
   ElementInContainerTypeInformation(MemberTypeInformation context,
       elementType)
       : super(context, elementType);
@@ skipping 143 matching lines @@
   }
 
   TypeMask safeType(TypeGraphInferrerEngine inferrer) => originalType;
 
   bool hasStableType(TypeGraphInferrerEngine inferrer) {
     return keyType.isStable &&
            valueType.isStable &&
            super.hasStableType(inferrer);
   }
 
-  void cleanup() {
-    super.cleanup();
-    keyType.cleanup();
-    valueType.cleanup();
-    for (TypeInformation info in typeInfoMap.values) {
-      info.cleanup();
-    }
-    _flowsInto = null;
-  }
-
   String toString() {
     return 'Map $type (K:$keyType, V:$valueType) contents $typeInfoMap';
   }
 }
 
 /**
  * A [KeyInMapTypeInformation] holds the common type
  * for the keys in a [MapTypeInformation]
  */
 class KeyInMapTypeInformation extends InferredTypeInformation {
@@ skipping 166 matching lines @@
   } else if (annotation.isVoid) {
     otherType = compiler.typesTask.nullType;
   } else {
     assert(annotation.isInterfaceType);
     otherType = new TypeMask.nonNullSubtype(annotation.element, compiler.world);
   }
   if (isNullable) otherType = otherType.nullable();
   if (type == null) return otherType;
   return type.intersection(otherType, compiler.world);
 }