[ddc] Add support for new generic interface types

- Introduce type environments in the compiler used for evaluating type
  parameters from generic classes and generic function types.

Issue: #48585
Change-Id: Ib5641eb666527acc3b7f13a4a00dea34e0122b52
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/266540
Reviewed-by: Mark Zhou <[email protected]>

Author: nshahan

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

@@ -19,10 +19,6 @@ abstract class FixedNames {
   static const operatorIsPrefix = r'$is_';
   static const operatorSignature = r'$signature';
   static const rtiName = r'$ti';
-  // TODO(48585) Fix this name.
-  static const futureClassName = 'TODO';
-  // TODO(48585) Fix this name.
-  static const listClassName = 'TODO';
   static const rtiAsField = '_as';
   static const rtiIsField = '_is';
 }

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

@@ -41,6 +41,7 @@ import 'native_types.dart';
 import 'nullable_inference.dart';
 import 'property_model.dart';
 import 'target.dart' show allowedNativeTest;
+import 'type_environment.dart';
 import 'type_recipe_generator.dart';
 import 'type_table.dart';
 
@@ -131,6 +132,12 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
   /// True when a class is emitting a deferred class hierarchy.
   bool _emittingDeferredType = false;
 
+  /// The current type environment of type parameters introduced to the scope
+  /// via generic classes and functions.
+  DDCTypeEnvironment _currentTypeEnvironment = const EmptyTypeEnvironment();
+
+  final TypeRecipeGenerator _typeRecipeGenerator;
+
   /// The current element being loaded.
   /// We can use this to determine if we're loading top-level code or not:
   ///
@@ -188,6 +195,9 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
 
   final _superHelpers = <String, js_ast.Method>{};
 
+  /// Cache for the results of calling [_typeParametersInHierarchy].
+  final _typeParametersInHierarchyCache = <Class, bool>{};
+
   // Compilation of Kernel's [BreakStatement].
   //
   // Kernel represents Dart's `break` and `continue` uniformly as
@@ -345,7 +355,8 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
         _asyncStarImplClass = sdk.getClass('dart:async', '_AsyncStarImpl'),
         _assertInteropMethod = sdk.getTopLevelMember(
             'dart:_runtime', 'assertInterop') as Procedure,
-        _futureOrNormalizer = FutureOrNormalizer(_coreTypes);
+        _futureOrNormalizer = FutureOrNormalizer(_coreTypes),
+        _typeRecipeGenerator = TypeRecipeGenerator(_coreTypes);
 
   @override
   Library? get currentLibrary => _currentLibrary;
@@ -682,6 +693,12 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     _currentClass = c;
     _currentLibrary = c.enclosingLibrary;
     _currentUri = c.fileUri;
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    // When compiling the type heritage of the class we can't reference an rti
+    // object attached to an instance. Instead we construct a type environment
+    // manually when needed. Later we use the rti attached to an instance for
+    // a simpler representation within instance members of the class.
+    _currentTypeEnvironment = _currentTypeEnvironment.extend(c.typeParameters);
 
     // Mixins are unrolled in _defineClass.
     // If this class is annotated with `@JS`, then there is nothing to emit.
@@ -697,6 +714,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     _currentClass = savedClass;
     _currentLibrary = savedLibrary;
     _currentUri = savedUri;
+    _currentTypeEnvironment = savedTypeEnvironment;
   }
 
   /// To emit top-level classes, we sometimes need to reorder them.
@@ -759,7 +777,15 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     });
 
     var jsCtors = _defineConstructors(c, className);
+    // Emitting class members in a class type environment results in a more
+    // succinct type representation when referencing class type arguments from
+    // instance members.
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    if (c.typeParameters.isNotEmpty) {
+      _currentTypeEnvironment = ClassTypeEnvironment(c.typeParameters);
+    }
     var jsMethods = _emitClassMethods(c);
+    _currentTypeEnvironment = savedTypeEnvironment;
 
     _emitSuperHelperSymbols(body);
     // Deferred supertypes must be evaluated lazily while emitting classes to
@@ -785,7 +811,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
 
     // Attach caches on all canonicalized types.
     if (_options.newRuntimeTypes) {
-      var name = TypeRecipeGenerator.interfaceTypeRecipe(c);
+      var name = _typeRecipeGenerator.interfaceTypeRecipe(c);
       body.add(runtimeStatement(
           'addRtiResources(#, #)', [className, js.string(name)]));
     }
@@ -1687,6 +1713,18 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     // multiple constructors, but it needs to be balanced against readability.
     body.add(_initializeFields(fields, node));
 
+    // Instances of classes with type arguments need an rti object attached to
+    // them since the type arguments could be instantiated differently for
+    // each instance.
+    if (_options.newRuntimeTypes && _typeParametersInHierarchy(cls)) {
+      var type = cls.getThisType(_coreTypes, Nullability.nonNullable);
+      // Only set the rti if there isn't one already. This avoids superclasses
+      // from overwriting the value already set by subclass.
+      var rtiProperty = propertyName(js_ast.FixedNames.rtiName);
+      body.add(js.statement(
+          'this.# = this.# || #', [rtiProperty, rtiProperty, _emitType(type)]));
+    }
+
     // If no superinitializer is provided, an implicit superinitializer of the
     // form `super()` is added at the end of the initializer list, unless the
     // enclosing class is class Object.
@@ -1700,6 +1738,19 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     return body;
   }
 
+  /// Returns `true` if [cls] or any of its transitive super classes has
+  /// generic type parameters.
+  bool _typeParametersInHierarchy(Class? cls) {
+    if (cls == null) return false;
+    var cachedResult = _typeParametersInHierarchyCache[cls];
+    if (cachedResult != null) return cachedResult;
+    var hasTypeParameters = cls.typeParameters.isNotEmpty
+        ? true
+        : _typeParametersInHierarchy(cls.superclass);
+    _typeParametersInHierarchyCache[cls] = hasTypeParameters;
+    return hasTypeParameters;
+  }
+
   js_ast.LiteralString _constructorName(String name) {
     if (name == '') {
       // Default constructors (factory or not) use `new` as their name.
@@ -2182,12 +2233,16 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     /// own type parameters, this will need to be changed to call
     /// [_emitFunction] instead.
     var name = node.name.text;
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    _currentTypeEnvironment =
+        _currentTypeEnvironment.extend(function.typeParameters);
     var jsBody = _emitSyncFunctionBody(function, name);
     var jsName = _constructorName(name);
     memberNames[node] = jsName.valueWithoutQuotes;
+    var jsParams = _emitParameters(function);
+    _currentTypeEnvironment = savedTypeEnvironment;
 
-    return js_ast.Method(jsName, js_ast.Fun(_emitParameters(function), jsBody),
-        isStatic: true)
+    return js_ast.Method(jsName, js_ast.Fun(jsParams, jsBody), isStatic: true)
       ..sourceInformation = _nodeEnd(node.fileEndOffset);
   }
 
@@ -2945,10 +3000,79 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
   /// Returns an expression that evaluates to the rti object from the dart:_rti
   /// library that represents [type].
   js_ast.Expression _newEmitType(DartType type) {
+    /// Returns an expression that evaluates a type [recipe] within the type
+    /// [environment].
+    ///
+    /// At runtime the expression will evaluate to an rti object.
+    js_ast.Expression emitRtiEval(
+            js_ast.Expression environment, String recipe) =>
+        js.call('#.#("$recipe")',
+            [environment, _emitMemberName('_eval', memberClass: rtiClass)]);
+
+    /// Returns an expression that binds a type [parameter] within the type
+    /// [environment].
+    ///
+    /// At runtime the expression will evaluate to an rti object that has been
+    /// extended to include the provided [parameter].
+    js_ast.Expression emitRtiBind(
+            js_ast.Expression environment, TypeParameter parameter) =>
+        js.call('#.#(#)', [
+          environment,
+          _emitMemberName('_bind', memberClass: rtiClass),
+          _emitTypeParameter(parameter)
+        ]);
+
+    /// Returns an expression that evaluates a type [recipe] in a type
+    /// [environment] resulting in an rti object.
+    js_ast.Expression evalInEnvironment(
+        DDCTypeEnvironment environment, String recipe) {
+      if (environment is EmptyTypeEnvironment) {
+        return js.call('#.findType("$recipe")', [emitLibraryName(rtiLibrary)]);
+      } else if (environment is BindingTypeEnvironment) {
+        js_ast.Expression env;
+        if (environment.isSingleTypeParameter) {
+          // An environment with a single type parameter can be simplified to
+          // just that parameter.
+          env = _emitTypeParameter(environment.parameters.single);
+        } else {
+          var environmentTypes = environment.parameters;
+          // Create a dummy interface type to "hold" type arguments.
+          env = emitRtiEval(_emitTypeParameter(environmentTypes.first), '@<0>');
+          // Bind remaining type arguments.
+          for (var i = 1; i < environmentTypes.length; i++) {
+            env = emitRtiBind(env, environmentTypes[i]);
+          }
+        }
+        return emitRtiEval(env, recipe);
+      } else if (environment is ClassTypeEnvironment) {
+        // Class type environments are already constructed and attached to the
+        // instance of a generic class.
+        return js.call('this.${js_ast.FixedNames.rtiName}');
+      } else if (environment is ExtendedClassTypeEnvironment) {
+        // A generic class instance already stores a reference to a type
+        // containing all of its type arguments.
+        var env = js.call('this.${js_ast.FixedNames.rtiName}');
+        // Bind extra type parameters.
+        for (var parameter in environment.extendedParameters) {
+          env = emitRtiBind(env, parameter);
+        }
+        return emitRtiEval(env, recipe);
+      } else {
+        _typeCompilationError(type,
+            'Unexpected DDCTypeEnvironment type (${environment.runtimeType}).');
+      }
+    }
+
+    // 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);
     try {
-      var recipe = normalizedType.accept(TypeRecipeGenerator());
-      return js.call('#.findType("$recipe")', [emitLibraryName(rtiLibrary)]);
+      var result = _typeRecipeGenerator.recipeInEnvironment(
+          normalizedType, _currentTypeEnvironment);
+      return evalInEnvironment(result.requiredEnvironment, result.recipe);
     } on UnsupportedError catch (e) {
       _typeCompilationError(normalizedType, e.message ?? 'Unknown Error');
     }
@@ -3443,6 +3567,8 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
   }
 
   js_ast.Fun _emitFunction(FunctionNode f, String? name) {
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    _currentTypeEnvironment = _currentTypeEnvironment.extend(f.typeParameters);
     // normal function (sync), vs (sync*, async, async*)
     var isSync = f.asyncMarker == AsyncMarker.Sync;
     var formals = _emitParameters(f);
@@ -3462,6 +3588,7 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
         : _emitGeneratorFunctionBody(f, name);
 
     block = super.exitFunction(formals, block);
+    _currentTypeEnvironment = savedTypeEnvironment;
     return js_ast.Fun(formals, block);
   }
 
@@ -5965,9 +6092,11 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
       case JsGetName.RTI_NAME:
         return js.string(js_ast.FixedNames.rtiName);
       case JsGetName.FUTURE_CLASS_TYPE_NAME:
-        return js.string(js_ast.FixedNames.futureClassName);
+        return js.string(
+            _typeRecipeGenerator.interfaceTypeRecipe(_coreTypes.futureClass));
       case JsGetName.LIST_CLASS_TYPE_NAME:
-        return js.string(js_ast.FixedNames.listClassName);
+        return js.string(
+            _typeRecipeGenerator.interfaceTypeRecipe(_coreTypes.listClass));
       case JsGetName.RTI_FIELD_AS:
         return _emitMemberName(js_ast.FixedNames.rtiAsField,
             memberClass: rtiClass);
@@ -6907,12 +7036,16 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
       return js_ast.Property(symbol, constant);
     }
 
-    var type = _emitInterfaceType(
-        node.getType(_staticTypeContext) as InterfaceType,
-        emitNullability: false);
-    var prototype = js.call('#.prototype', [type]);
+    var type = node.getType(_staticTypeContext);
+    var classRef =
+        _emitInterfaceType(type as InterfaceType, emitNullability: false);
+    var prototype = js.call('#.prototype', [classRef]);
     var properties = [
       js_ast.Property(propertyName('__proto__'), prototype),
+      if (_options.newRuntimeTypes && type.typeArguments.isNotEmpty)
+        // Generic interface type instances require a type information tag.
+        js_ast.Property(
+            propertyName(js_ast.FixedNames.rtiName), _emitType(type)),
       for (var e in node.fieldValues.entries.toList().reversed)
         entryToProperty(e),
     ];

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

@@ -371,3 +371,12 @@ bool _isNativeMarkerAnnotation(Expression annotation) {
 
 bool _isDartInternal(Uri uri) =>
     uri.isScheme('dart') && uri.path == '_internal';
+
+/// Collects all `TypeParameter`s from the `TypeParameterType`s present in the
+/// visited `DartType`.
+class TypeParameterTypeFinder extends RecursiveVisitor<void> {
+  final found = <TypeParameter>{};
+  @override
+  void visitTypeParameterType(TypeParameterType node) =>
+      found.add(node.parameter);
+}