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`.
    */
-  final Map<Element, Setlet<Spannable>> _callers = new Map<Element, Setlet>();
+  Map<Element, Setlet<Spannable>> _callers;
 
   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 => _callers.keys;
+  Iterable<Element> get callers {
+    // TODO(sra): This is called only from an unused API and a test. If it
+    // becomes used, [cleanup] will need to copy `_caller.keys`.
+
+    // `simple_inferrer_callers_test.dart` ensures that cleanup has not
+    // happened.
+    return _callers.keys;
+  }
 
   bool isCalledOnce() {
+    // If this assert fires it means that this MemberTypeInformation for the
+    // element was not part of type inference. This happens for
+    // ConstructorBodyElements, so guard the call with a test for
+    // ConstructorBodyElement. For other elements, investigate why the element
+    // was not present for type inference.
+    assert(_isCalledOnce != null);
+    return _isCalledOnce ?? false;
+  }
+
+  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() {
+    // This node is on multiple lists so cleanup() can be called twice.
+    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);
 }