[ddc] Add module local caches for new types

- Provides fast access for types that are used multiple times in the
  same module.
- Enable the existing type table cache when running with new types.
- Add a similar cache for instantiated generic classes. This cache
  is used in the current type system as well to help keep the
  difference between types and classes more clear.

Issue: #48585
Change-Id: I32103cf0c0bcf9b9771e789c0d04e63a4365a066
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/321320
Commit-Queue: Nicholas Shahan <[email protected]>
Reviewed-by: Mark Zhou <[email protected]>

Author: nshahan

pkg/dev_compiler/lib/src/kernel/compiler.dart

@@ -172,6 +172,11 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
   /// Table of named and possibly hoisted types.
   late TypeTable _typeTable;
 
+  /// Table of instantiated generic class references.
+  ///
+  /// Provides a cache for the instantiated generic types local to a module.
+  late TypeTable _genericClassTable;
+
   /// The global extension type table.
   // TODO(jmesserly): rename to `_nativeTypes`
   final NativeTypeSet _extensionTypes;
@@ -367,6 +372,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
         _assertInteropMethod = sdk.getTopLevelMember(
             'dart:_runtime', 'assertInterop') as Procedure,
         _futureOrNormalizer = FutureOrNormalizer(_coreTypes),
+        _extensionTypeEraser = ExtensionTypeEraser(),
         _typeRecipeGenerator = TypeRecipeGenerator(_coreTypes, _hierarchy),
         _extensionIndex =
             ExtensionIndex(_coreTypes, _staticTypeContext.typeEnvironment);
@@ -390,6 +396,8 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
 
   final FutureOrNormalizer _futureOrNormalizer;
 
+  final ExtensionTypeEraser _extensionTypeEraser;
+
   /// Module can be emitted only once, and the compiler can be reused after
   /// only in incremental mode, for expression compilation only.
   js_ast.Program emitModule(Component component) {
@@ -451,7 +459,8 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     }
 
     _nullableInference.allowNotNullDeclarations = isBuildingSdk;
-    _typeTable = TypeTable(runtimeCall);
+    _typeTable = TypeTable('T', runtimeCall);
+    _genericClassTable = TypeTable('G', runtimeCall);
 
     // Collect all class/type Element -> Node mappings
     // in case we need to forward declare any classes.
@@ -616,6 +625,10 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     items.addAll(_typeTable.dischargeBoundTypes());
     _ticker?.logMs('Emitted type table');
 
+    // Emit the hoisted instantiated generic class table cache variables
+    items.addAll(_genericClassTable.dischargeBoundTypes());
+    _ticker?.logMs('Emitted instantiated generic class table');
+
     var module = finishModule(items, _options.moduleName,
         header: generateCompilationHeader());
     _ticker?.logMs('Finished emitting module');
@@ -1057,8 +1070,13 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
       body = js_ast.Statement.from([body, varianceStatement]);
     }
 
-    var typeConstructor = js.call('(#) => { #; #; return #; }',
-        [jsFormals, _typeTable.dischargeFreeTypes(formals), body, className]);
+    var typeConstructor = js.call('(#) => { #; #; #; return #; }', [
+      jsFormals,
+      _typeTable.dischargeFreeTypes(formals),
+      _genericClassTable.dischargeFreeTypes(formals),
+      body,
+      className
+    ]);
 
     var genericArgs = [
       typeConstructor,
@@ -1268,6 +1286,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
         if (t is RecordType) {
           return t.positional.any(defer) || t.named.any((n) => defer(n.type));
         }
+        if (t is ExtensionType) return defer(t.typeErasure);
         return false;
       }
 
@@ -1631,7 +1650,10 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     _classEmittingSignatures = c;
 
     var interfaces = c.implementedTypes.toList()..addAll(c.onClause);
-    if (interfaces.isNotEmpty) {
+    if (interfaces.isNotEmpty &&
+        // New runtime types don't use this data structure to lookup interfaces
+        // a class implements.
+        !_options.newRuntimeTypes) {
       body.add(js.statement('#[#] = () => [#];', [
         className,
         runtimeCall('implements'),
@@ -3260,6 +3282,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     if (type is TypedefType) {
       return type.typeArguments.every(_canEmitTypeAtTopLevel);
     }
+    if (type is ExtensionType) return _canEmitTypeAtTopLevel(type.typeErasure);
     return true;
   }
 
@@ -3304,6 +3327,8 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
           // An environment with a single type parameter can be simplified to
           // just that parameter.
           env = _emitTypeParameter(environment.parameters.single);
+          // Skip a no-op evaluation and just return the parameter.
+          if (recipe == '0') return env;
         } else {
           var environmentTypes = environment.parameters;
           // Create a dummy interface type to "hold" type arguments.
@@ -3334,16 +3359,15 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
       }
     }
 
-    // TODO(nshahan) Avoid calling _emitType when we actually want a
-    // reference to an rti that already exists in scope.
-    if (type is TypeParameterType && type.isPotentiallyNonNullable) {
-      return _emitTypeParameterType(type, emitNullability: false);
-    }
-    var normalizedType = _futureOrNormalizer.normalize(type);
+    var normalizedType =
+        _futureOrNormalizer.normalize(_extensionTypeEraser.erase(type));
     try {
       var result = _typeRecipeGenerator.recipeInEnvironment(
           normalizedType, _currentTypeEnvironment);
-      return evalInEnvironment(result.requiredEnvironment, result.recipe);
+      var typeRep =
+          evalInEnvironment(result.requiredEnvironment, result.recipe);
+      if (_cacheTypes) typeRep = _typeTable.nameType(normalizedType, typeRep);
+      return typeRep;
     } on UnsupportedError catch (e) {
       _typeCompilationError(normalizedType, e.message ?? 'Unknown Error');
     }
@@ -3496,7 +3520,10 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     if (args.any((a) => a != const DynamicType())) {
       jsArgs = args.map(_emitType);
     }
-    if (jsArgs != null) return _emitGenericClassType(type, jsArgs);
+    if (jsArgs != null) {
+      return _genericClassTable.nameType(
+          type, _emitGenericClassType(type, jsArgs));
+    }
     return _emitTopLevelNameNoExternalInterop(type.classNode);
   }
 
@@ -3567,11 +3594,12 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
   bool get _emittingClassExtends =>
       _currentClass != null && identical(_currentClass, _classEmittingExtends);
 
-  bool get _cacheTypes =>
-      !_emittingDeferredType &&
-          !_emittingClassExtends &&
-          !_emittingClassSignatures ||
-      _currentFunction != null;
+  bool get _cacheTypes => _options.newRuntimeTypes
+      ? !_emittingDeferredType && !_emittingClassExtends
+      : !_emittingDeferredType &&
+              !_emittingClassExtends &&
+              !_emittingClassSignatures ||
+          _currentFunction != null;
 
   js_ast.Expression _emitGenericClassType(
       InterfaceType t, Iterable<js_ast.Expression> typeArgs) {
@@ -3853,6 +3881,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     var body = js_ast.Block([
       ...extensionSymbols,
       ..._typeTable.dischargeBoundTypes(),
+      ..._genericClassTable.dischargeBoundTypes(),
       ...symbolContainer.emit(),
       ..._emitConstTable(),
       ..._uriContainer.emit(),
@@ -6851,23 +6880,21 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
   js_ast.Expression _emitMapImplType(InterfaceType type, {bool? identity}) {
     var typeArgs = type.typeArguments;
     if (typeArgs.isEmpty) {
-      return _emitInterfaceType(type, emitNullability: false);
+      return _emitClassRef(type);
     }
     identity ??= _typeRep.isPrimitive(typeArgs[0]);
     var c = identity ? _identityHashMapImplClass : _linkedHashMapImplClass;
-    return _emitInterfaceType(InterfaceType(c, Nullability.legacy, typeArgs),
-        emitNullability: false);
+    return _emitClassRef(InterfaceType(c, Nullability.legacy, typeArgs));
   }
 
   js_ast.Expression _emitSetImplType(InterfaceType type, {bool? identity}) {
     var typeArgs = type.typeArguments;
     if (typeArgs.isEmpty) {
-      return _emitInterfaceType(type, emitNullability: false);
+      return _emitClassRef(type);
     }
     identity ??= _typeRep.isPrimitive(typeArgs[0]);
     var c = identity ? _identityHashSetImplClass : _linkedHashSetImplClass;
-    return _emitInterfaceType(InterfaceType(c, Nullability.legacy, typeArgs),
-        emitNullability: false);
+    return _emitClassRef(InterfaceType(c, Nullability.legacy, typeArgs));
   }
 
   js_ast.Expression _emitObjectLiteral(Arguments node, Member ctor) {
@@ -7199,9 +7226,8 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     if (itemType == const DynamicType()) return list;
 
     // Call `new JSArray<E>.of(list)`
-    var arrayType = _emitInterfaceType(
-        InterfaceType(_jsArrayClass, Nullability.legacy, [itemType]),
-        emitNullability: false);
+    var arrayType = _emitClassRef(
+        InterfaceType(_jsArrayClass, Nullability.nonNullable, [itemType]));
     return js.call('#.of(#)', [arrayType, list]);
   }
 
@@ -7217,10 +7243,8 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
   js_ast.Expression visitSetLiteral(SetLiteral node) {
     // TODO(markzipan): remove const check when we use front-end const eval
     if (!node.isConst) {
-      var setType = _emitInterfaceType(
-          InterfaceType(
-              _linkedHashSetClass, Nullability.legacy, [node.typeArgument]),
-          emitNullability: false);
+      var setType = _emitClassRef(InterfaceType(
+          _linkedHashSetClass, Nullability.legacy, [node.typeArgument]));
       if (node.expressions.isEmpty) {
         return js.call('#.new()', [setType]);
       }
@@ -7674,8 +7698,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     var type = node
         .getType(_staticTypeContext)
         .withDeclaredNullability(Nullability.nonNullable);
-    var classRef =
-        _emitInterfaceType(type as InterfaceType, emitNullability: false);
+    var classRef = _emitClassRef(type as InterfaceType);
     var prototype = js.call('#.prototype', [classRef]);
     var properties = [
       if (_options.newRuntimeTypes && type.typeArguments.isNotEmpty)

pkg/dev_compiler/lib/src/kernel/js_typerep.dart

@@ -60,6 +60,7 @@ class JSTypeRep extends SharedJSTypeRep<DartType> {
     if (type == const DynamicType() || type == const VoidType()) {
       return JSType.jsUnknown;
     }
+    if (type is ExtensionType) typeFor(type.typeErasure);
     return JSType.jsObject;
   }
 

pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart

@@ -6,6 +6,7 @@ import 'dart:collection';
 import 'package:collection/collection.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/kernel.dart' hide Pattern;
+import 'package:kernel/src/replacement_visitor.dart';
 
 Constructor? unnamedConstructor(Class c) =>
     c.constructors.firstWhereOrNull((c) => c.name.text == '');
@@ -290,6 +291,7 @@ class LabelContinueFinder extends RecursiveVisitor<void> {
 /// code if used in an assert.
 bool isKnownDartTypeImplementor(DartType t) {
   return t is DynamicType ||
+      t is ExtensionType ||
       t is FunctionType ||
       t is FutureOrType ||
       t is InterfaceType ||
@@ -366,3 +368,15 @@ class InterfaceTypeExtractor extends RecursiveVisitor<DartType> {
     return _found;
   }
 }
+
+class ExtensionTypeEraser extends ReplacementVisitor {
+  const ExtensionTypeEraser();
+
+  /// Erases all `ExtensionType` nodes found in [type].
+  DartType erase(DartType type) =>
+      type.accept1(this, Variance.unrelated) ?? type;
+
+  @override
+  DartType? visitExtensionType(ExtensionType node, int variance) =>
+      node.typeErasure.accept1(this, Variance.unrelated) ?? node.typeErasure;
+}

pkg/dev_compiler/lib/src/kernel/type_table.dart

@@ -35,6 +35,8 @@ Set<TypeParameter> freeTypeParameters(DartType t) {
     } else if (t is RecordType) {
       t.positional.forEach((p) => find(p));
       t.named.forEach((n) => find(n.type));
+    } else if (t is ExtensionType) {
+      find(t.typeErasure);
     }
   }
 
@@ -102,6 +104,7 @@ String _typeString(DartType type, {bool flat = false}) {
     }
     return 'Rec${nullability}Of$elements';
   }
+  if (type is ExtensionType) return _typeString(type.typeErasure);
   return 'invalid';
 }
 
@@ -120,12 +123,13 @@ class TypeTable {
   final _unboundTypeIds = HashMap<DartType, js_ast.Identifier>();
 
   /// Holds JS type generators keyed by their underlying DartType.
-  final typeContainer = ModuleItemContainer<DartType>.asObject('T',
-      keyToString: (DartType t) => escapeIdentifier(_typeString(t))!);
+  final ModuleItemContainer<DartType> typeContainer;
 
   final js_ast.Expression Function(String, [List<Object>]) _runtimeCall;
 
-  TypeTable(this._runtimeCall);
+  TypeTable(String name, this._runtimeCall)
+      : typeContainer = ModuleItemContainer<DartType>.asObject(name,
+            keyToString: (DartType t) => escapeIdentifier(_typeString(t))!);
 
   /// Returns true if [type] is already recorded in the table.
   bool _isNamed(DartType type) =>