[dartdevc] Using a single cache for _typeObject and normalized types.

Change-Id: I7e3c994b7eec2cb4bc25a153fa177a39d5217b38
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/132101
Commit-Queue: Mark Zhou <[email protected]>
Reviewed-by: Mark Zhou <[email protected]>

Author: sigmundch

sdk_nnbd/lib/_internal/js_dev_runtime/private/ddc_runtime/types.dart

@@ -390,47 +390,48 @@ class _Type extends Type {
 
 /// Given an internal runtime type object, wraps it in a `_Type` object
 /// that implements the dart:core Type interface.
-Type wrapType(type) {
+Type wrapType(type) => _wrapType(type, false);
+
+/// Helper function to wrap a type.
+///
+/// When isNormalized is true, the parameter is known to be in a canonicalized
+/// normal form, so the algorithm can directly wrap and return the value.
+Type _wrapType(type, isNormalized) {
   // If we've already wrapped this type once, use the previous wrapper. This
   // way, multiple references to the same type return an identical Type.
   if (JS('!', '#.hasOwnProperty(#)', type, _typeObject)) {
     return JS('', '#[#]', type, _typeObject);
   }
-  var result = JS<Type?>('', '#.get(#)', _normalizedTypeObjectMap, type) ??
-      canonicalizeNormalizedTypeObject(type);
+  var result = isNormalized
+      ? _Type(type)
+      : (type is LegacyType
+          ? _wrapType(type.type, false)
+          : _canonicalizeNormalizedTypeObject(type));
   JS('', '#[#] = #', type, _typeObject, result);
   return result;
 }
 
-/// Constructs and caches a normalized version of a type.
+/// Constructs a normalized version of a type.
 ///
 /// Used for type object identity. Currently only removes legacy wrappers,
 /// ignoring other normalization operations.
-Type canonicalizeNormalizedTypeObject(dartType) {
-  // Check if a normalized type corresponding to this type has already been
-  // generated. Search for and potentially cache both the type and its
-  // legacy-wrapped version.
-  var result = JS<Type?>('', '#.get(#)', _normalizedTypeObjectMap, dartType);
-  if (result != null) {
-    return result;
-  }
-  var type = dartType is LegacyType ? dartType.type : dartType;
-  var legacyType = legacy(type);
+Type _canonicalizeNormalizedTypeObject(type) {
+  assert(type is! LegacyType);
   var args = getGenericArgs(type);
+  var normType;
   if (args == null || args.isEmpty) {
-    var norm = _Type(type);
-    JS('', '#.set(#, #)', _normalizedTypeObjectMap, type, norm);
-    JS('', '#.set(#, #)', _normalizedTypeObjectMap, legacyType, norm);
-    return norm;
-  }
-  var genericClass = getGenericClass(type);
-  var normArgs = args
-      .map((generic) => unwrapType(canonicalizeNormalizedTypeObject(generic)))
-      .toList();
-  var norm = _Type(constFn(JS('!', '#(...#)', genericClass, normArgs))());
-  JS('', '#.set(#, #)', _normalizedTypeObjectMap, type, norm);
-  JS('', '#.set(#, #)', _normalizedTypeObjectMap, legacyType, norm);
-  return norm;
+    normType = type;
+  } else {
+    var genericClass = getGenericClass(type);
+    // We don't call _canonicalizeNormalizedTypeObject recursively but call wrap
+    // + unwrap to handle legacy types automatically and force caching the
+    // canonicalized type under the _typeObject cache property directly. This
+    // way we ensure we always use the canonical normalized instance for each
+    // type parameter.
+    var normArgs = args.map((a) => unwrapType(wrapType(a))).toList();
+    normType = JS('!', '#(...#)', genericClass, normArgs);
+  }
+  return _wrapType(normType, true);
 }
 
 /// The symbol used to store the cached `Type` object associated with a class.
@@ -471,10 +472,6 @@ final _fnTypeTypeMap = JS('', 'new Map()');
 /// index path (if present) is the canonical function type.
 final List _fnTypeSmallMap = JS('', '[new Map(), new Map(), new Map()]');
 
-/// Memo table that maps DartType objects to their type objects (`_Type`).
-/// Used for computing identity for runtime type objects.
-final _normalizedTypeObjectMap = JS('', 'new Map()');
-
 @NoReifyGeneric()
 T _memoizeArray<T>(map, arr, T create()) => JS('', '''(() => {
   let len = $arr.length;

tests/language/nnbd/type_object/equality_test.dart

@@ -12,6 +12,8 @@ class B {}
 
 Type type<T>() => T;
 
+Type listType<T>() => <T>[].runtimeType;
+
 main() {
   var a = new A();
   var b = new B();
@@ -38,4 +40,6 @@ main() {
   Expect.isFalse(legacyType<int>() == type<int?>());
   Expect.isTrue(legacyType<int>() == type<int>());
   Expect.isTrue(legacyType<int>() == legacyType<int>());
+
+  Expect.isTrue(listType<int>() == legacyListType<int>());
 }

tests/language/nnbd/type_object/legacy_library.dart

@@ -6,3 +6,4 @@
 // @dart = 2.6
 
 Type legacyType<T>() => T;
+Type legacyListType<T>() => <T>[].runtimeType;