diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index 11e9546..124a5b9 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -203,8 +203,12 @@
 
   final _superHelpers = <String, js_ast.Method>{};
 
-  /// Cache for the results of calling [_typeParametersInHierarchy].
-  final _typeParametersInHierarchyCache = <Class, bool>{};
+  /// Cache for the results of calling [_requiresRtiForInstantiation].
+  final _requiresRtiForInstantiationCache = <Class, bool>{};
+
+  /// Reserved parameter used to reference RTI objects passed to generic
+  /// constructors/factories and generic method signatures.
+  final _rtiParam = js_ast.TemporaryId('_ti');
 
   // Compilation of Kernel's [BreakStatement].
   //
@@ -705,6 +709,22 @@
       _moduleItems.add(addTypeParameterVariancesStatement);
     }
 
+    // Certain RTIs must be emitted during RTI normalization. We cache these
+    // eagerly with 'findType' (without normalization) to avoid infinite loops.
+    // See normalization functions in: sdk/lib/_internal/js_shared/lib/rti.dart
+    var prerequisiteRtiTypes = [
+      _coreTypes.objectLegacyRawType,
+      _coreTypes.objectNullableRawType,
+      NeverType.legacy()
+    ];
+    prerequisiteRtiTypes.forEach((type) {
+      var recipe = _typeRecipeGenerator
+          .recipeInEnvironment(type, EmptyTypeEnvironment())
+          .recipe;
+      _moduleItems.add(js.call('#.findType("$recipe")',
+          [_emitLibraryName(_rtiLibrary)]).toStatement());
+    });
+
     // Visit directives (for exports)
     libraries.forEach(_emitExports);
     _ticker?.logMs('Emitted exports');
@@ -931,7 +951,7 @@
     // 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);
+    _currentTypeEnvironment = ClassTypeEnvironment(c.typeParameters);
 
     // Mixins are unrolled in _defineClass.
     if (!c.isAnonymousMixin) {
@@ -979,18 +999,7 @@
       js_ast.TemporaryId(js_ast.toJSIdentifier(name));
 
   js_ast.Statement _emitClassDeclaration(Class c) {
-    // Generic classes will be defined inside a function that closes over the
-    // type parameter. So we can use their local variable name directly.
-    //
-    // TODO(jmesserly): the special case for JSArray is to support its special
-    // type-tagging factory constructors. Those will go away once we fix:
-    // https://github.com/dart-lang/sdk/issues/31003
-    var className = c.typeParameters.isNotEmpty
-        ? (c == _jsArrayClass
-            ? _emitIdentifier(c.name)
-            : _emitTemporaryId(getLocalClassName(c)))
-        : _emitTopLevelName(c);
-
+    var className = _emitTopLevelNameNoExternalInterop(c);
     var savedClassProperties = _classProperties;
     _classProperties =
         ClassPropertyModel.build(_types, _extensionTypes, _virtualFields, c);
@@ -1017,13 +1026,6 @@
 
     var jsCtors = _defineConstructors(c, className);
 
-    // TODO(nshahan) Use ClassTypeEnvironment when the representation of generic
-    // classes is no longer a closure that defines the class and captures the
-    // type arguments.
-    // Emitting class members in a class type environment results in a more
-    // succinct type representation when referencing class type arguments from
-    // instance members but the type rules must include mappings of all type
-    // arguments throughout the hierarchy.
     var jsMethods = _emitClassMethods(c);
 
     _emitSuperHelperSymbols(body);
@@ -1087,18 +1089,17 @@
       _defineExtensionMembers(className, body);
     }
 
-    var classDef = js_ast.Statement.from(body);
     var typeFormals = c.typeParameters;
     var evaluatedDeferredSupertypes =
         deferredSupertypes.map<js_ast.Statement>((f) => f()).toList();
     if (typeFormals.isNotEmpty) {
-      classDef = _defineClassTypeArguments(
-          c, typeFormals, classDef, className, evaluatedDeferredSupertypes);
+      var genericClassStmts = _defineGenericClass(typeFormals,
+          js_ast.Statement.from(body), evaluatedDeferredSupertypes);
+      body = [...genericClassStmts];
     } else {
       _afterClassDefItems.addAll(evaluatedDeferredSupertypes);
     }
 
-    body = [classDef];
     _emitStaticFieldsAndAccessors(c, body);
     if (c == _coreTypes.objectClass) {
       // Avoid polluting the native JavaScript Object prototype with the members
@@ -1121,11 +1122,7 @@
   /// or static members, returns null.
   js_ast.Statement? _emitJSInteropClassNonExternalMembers(Class c) {
     if (!hasJSInteropAnnotation(c)) return null;
-    // Generic JS interop classes are emitted like Dart generic classes, where
-    // the type arguments need to be instantiated.
-    var className = c.typeParameters.isNotEmpty
-        ? _emitTemporaryId(getLocalClassName(c))
-        : _emitTopLevelNameNoExternalInterop(c);
+    var className = _emitTopLevelNameNoExternalInterop(c);
 
     var nonExternalMethods = <js_ast.Method>[];
     for (var procedure in c.procedures) {
@@ -1154,59 +1151,32 @@
         _emitClassStatement(c, className, null, nonExternalMethods)
             .toStatement()
       ];
-      var classDef = js_ast.Statement.from(body);
       var typeFormals = c.typeParameters;
       if (typeFormals.isNotEmpty) {
-        classDef =
-            _defineClassTypeArguments(c, typeFormals, classDef, className, []);
+        var genericClassStmts =
+            _defineGenericClass(typeFormals, js_ast.Statement.from(body), []);
+        body = [...genericClassStmts, ...fieldInitialization];
+      } else {
+        body = [...body, ...fieldInitialization];
       }
-      body = [classDef, ...fieldInitialization];
       return js_ast.Statement.from(body);
     }
     return null;
   }
 
-  /// Wraps a possibly generic class in its type arguments.
-  js_ast.Statement _defineClassTypeArguments(
-      NamedNode c,
-      List<TypeParameter> formals,
-      js_ast.Statement body,
-      js_ast.Expression className,
-      List<js_ast.Statement> deferredBaseClass) {
+  /// Emits a generic class with additional initialization logic.
+  List<js_ast.Statement> _defineGenericClass(List<TypeParameter> formals,
+      js_ast.Statement body, List<js_ast.Statement> deferredBaseClass) {
     assert(formals.isNotEmpty);
-    var jsFormals = _emitTypeFormals(formals);
-    var typeConstructor = js.call('(#) => { #; #; #; return #; }', [
-      jsFormals,
-      _typeTable.dischargeFreeTypes(formals),
-      _genericClassTable.dischargeFreeTypes(formals),
+    return [
+      ..._typeTable.dischargeFreeTypes(formals),
       body,
-      className
-    ]);
-
-    var genericArgs = [
-      typeConstructor,
-      if (deferredBaseClass.isNotEmpty)
-        js.call('(#) => { #; }', [jsFormals, deferredBaseClass]),
+      ...deferredBaseClass,
     ];
-    var genericCall = _runtimeCall('generic(#)', [genericArgs]);
-    var genericName = _emitTopLevelNameNoExternalInterop(c, suffix: '\$');
-    return js.statement('{ # = #; # = #(); }', [
-      genericName,
-      genericCall,
-      _emitTopLevelNameNoExternalInterop(c),
-      genericName
-    ]);
   }
 
   js_ast.Statement _emitClassStatement(Class c, js_ast.Expression className,
       js_ast.Expression? heritage, List<js_ast.Method> methods) {
-    if (c.typeParameters.isNotEmpty) {
-      var classIdentifier = className as js_ast.Identifier;
-      if (_options.emitDebugSymbols) classIdentifiers[c] = classIdentifier;
-      return js_ast.ClassExpression(classIdentifier, heritage, methods)
-          .toStatement();
-    }
-
     var classIdentifier = _emitTemporaryId(getLocalClassName(c));
     if (_options.emitDebugSymbols) classIdentifiers[c] = classIdentifier;
     var classExpr = js_ast.ClassExpression(classIdentifier, heritage, methods);
@@ -1323,23 +1293,11 @@
       return base;
     }
 
-    /// Returns the "actual" superclass of [c].
-    ///
-    /// Walks up the superclass chain looking for the first actual class
-    /// skipping any synthetic classes inserted by the CFE.
-    Class superClassAsWritten(Class c) {
-      var superclass = c.superclass!;
-      while (superclass.isAnonymousMixin) {
-        superclass = superclass.superclass!;
-      }
-      return superclass;
-    }
-
     // Find the real (user declared) superclass and the list of mixins.
     // We'll use this to unroll the intermediate classes.
     //
     // TODO(jmesserly): consider using Kernel's mixin unrolling.
-    var superclass = superClassAsWritten(c);
+    var superclass = _superClassAsWritten(c);
     var supertype = identical(c.superclass, superclass)
         ? c.supertype!.asInterfaceType
         : _hierarchy.getClassAsInstanceOf(c, superclass)!.asInterfaceType;
@@ -1354,32 +1312,48 @@
 
     var hasUnnamedSuper = _hasUnnamedInheritedConstructor(superclass);
 
-    void emitMixinConstructors(
-        js_ast.Expression className, InterfaceType mixin) {
-      js_ast.Statement? mixinCtor;
-      if (_hasUnnamedConstructor(mixin.classNode)) {
-        mixinCtor = js.statement('#.#.call(this);', [
-          emitClassRef(mixin),
-          _usesMixinNew(mixin.classNode)
-              ? _runtimeCall('mixinNew')
-              : _constructorName('')
-        ]);
-      }
-
-      for (var ctor in superclass.constructors) {
+    void emitMixinConstructors(js_ast.Expression className,
+        Class mixinSuperclass, Class mixinClass, InterfaceType mixin) {
+      for (var ctor in mixinSuperclass.constructors) {
         var savedUri = _currentUri;
         _currentUri = ctor.enclosingClass.fileUri;
-        var jsParams = _emitParameters(ctor.function, isForwarding: true);
-        _currentUri = savedUri;
+
+        var sharedParams = _emitParameters(ctor.function, isForwarding: true);
+        var mixinConstructorParams = [
+          if (_requiresRtiForInstantiation(mixinSuperclass)) _rtiParam,
+          ...sharedParams
+        ];
+        var superConstructorArgs = [
+          if (_requiresRtiForInstantiation(ctor.enclosingClass))
+            js_ast.LiteralNull(),
+          ...sharedParams
+        ];
+
+        js_ast.Statement? mixinCtor;
+        if (_hasUnnamedConstructor(mixin.classNode)) {
+          var mixinRti = _requiresRtiForInstantiation(mixin.classNode)
+              ? js_ast.LiteralNull()
+              : null;
+          mixinCtor = js.statement('#.#.call(this, #);', [
+            emitClassRef(mixin),
+            _usesMixinNew(mixin.classNode)
+                ? _runtimeCall('mixinNew')
+                : _constructorName(''),
+            [if (mixinRti != null) mixinRti],
+          ]);
+        }
+
         var name = ctor.name.text;
         var ctorBody = [
           if (mixinCtor != null) mixinCtor,
           if (name != '' || hasUnnamedSuper)
-            _emitSuperConstructorCall(className, name, jsParams),
+            _emitSuperConstructorCall(
+                ctor, className, name, superConstructorArgs),
         ];
         // TODO(nshahan) Record the name for this constructor in memberNames.
         body.add(_addConstructorToClass(c, className, _constructorName(name),
-            js_ast.Fun(jsParams, js_ast.Block(ctorBody))));
+            js_ast.Fun(mixinConstructorParams, js_ast.Block(ctorBody))));
+        _currentUri = savedUri;
       }
     }
 
@@ -1418,8 +1392,10 @@
       // parameters from the class being mixed in and their use can appear in
       // the forwarding stubs.
       var savedTypeEnvironment = _currentTypeEnvironment;
-      _currentTypeEnvironment =
-          _currentTypeEnvironment.extend(m.typeParameters);
+      if (m.typeParameters.isNotEmpty) {
+        assert(_currentTypeEnvironment is ClassTypeEnvironment);
+        _currentTypeEnvironment = ClassTypeEnvironment(m.typeParameters);
+      }
       var forwardingMethodStubs = <js_ast.Method>[];
       for (var s in forwardingMembers.values) {
         // Members are marked as "forwarding stubs" when they require a type
@@ -1449,7 +1425,7 @@
             _emitTemporaryId(mixinName), baseClass, forwardingMethodStubs)
       ]));
 
-      emitMixinConstructors(mixinId, mixinType);
+      emitMixinConstructors(mixinId, superclass, mixinClass, mixinType);
       hasUnnamedSuper = hasUnnamedSuper || _hasUnnamedConstructor(mixinClass);
 
       if (shouldDefer(mixinType)) {
@@ -1574,6 +1550,9 @@
   /// Emit the signature on the class recording the runtime type information
   void _emitClassSignature(
       Class c, js_ast.Expression className, List<js_ast.Statement> body) {
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    _currentTypeEnvironment =
+        RtiTypeEnvironment(_currentTypeEnvironment.classTypeParameters);
     var savedClass = _classEmittingSignatures;
     _classEmittingSignatures = c;
 
@@ -1608,6 +1587,25 @@
       body.add(setSignature);
     }
 
+    js_ast.Expression emitClassFieldSignature(Field field, Class fromClass) {
+      var fieldType =
+          _typeFromClass(field.type, field.enclosingClass!, fromClass)
+              .extensionTypeErasure;
+      var uri = fieldType is InterfaceType
+          ? _cacheUri(
+              _jsLibraryDebuggerName(fieldType.classNode.enclosingLibrary))
+          : null;
+      var isConst = js.boolean(field.isConst);
+      var isFinal = js.boolean(field.isFinal);
+      var type = _emitType(fieldType);
+      var typeResolver = js_ast.ArrowFun([_rtiParam], type);
+      return uri == null
+          ? js('{type: #, isConst: #, isFinal: #}',
+              [typeResolver, isConst, isFinal])
+          : js('{type: #, isConst: #, isFinal: #, libraryUri: #}',
+              [typeResolver, isConst, isFinal, uri]);
+    }
+
     var extMethods = _classProperties!.extensionMethods;
     var extAccessors = _classProperties!.extensionAccessors;
     var staticMethods = <js_ast.Property>[];
@@ -1689,28 +1687,32 @@
               for (var parameter in reifiedType.typeParameters)
                 _emitType(parameter.defaultType)
             ]);
-            instanceMethodsDefaultTypeArgs
-                .add(js_ast.Property(memberName, defaultTypeArgs));
+            var typeResolver = js_ast.ArrowFun([_rtiParam], defaultTypeArgs);
+            var property = js_ast.Property(memberName, typeResolver);
+            instanceMethodsDefaultTypeArgs.add(property);
             // As seen below, sometimes the member signatures are added again
             // using the extension symbol as the name. That logic is duplicated
             // here to ensure there are always default type arguments accessible
             // via the same name as the signature.
             // TODO(52867): Cleanup default type argument duplication.
             if (extMethods.contains(name) || extAccessors.contains(name)) {
-              instanceMethodsDefaultTypeArgs.add(js_ast.Property(
-                  _declareMemberName(member, useExtension: true),
-                  defaultTypeArgs));
+              var property = js_ast.Property(
+                  _declareMemberName(member, useExtension: true), typeResolver);
+              instanceMethodsDefaultTypeArgs.add(property);
             }
           }
         }
-        var property = js_ast.Property(memberName, type);
+        var typeResolver = js_ast.ArrowFun([_rtiParam], type);
+        var property = js_ast.Property(memberName, typeResolver);
         var signatures = getSignatureList(member);
         signatures.add(property);
         if (!member.isStatic &&
             (extMethods.contains(name) || extAccessors.contains(name))) {
           // TODO(52867): Cleanup signature duplication.
-          signatures.add(js_ast.Property(
-              _declareMemberName(member, useExtension: true), type));
+          var typeResolver = js_ast.ArrowFun([_rtiParam], type);
+          var property = js_ast.Property(
+              _declareMemberName(member, useExtension: true), typeResolver);
+          signatures.add(property);
         }
       }
     }
@@ -1736,34 +1738,18 @@
       // signatures are only used by the debugger and are not needed for runtime
       // correctness.
       var memberName = _declareMemberName(field);
-      var fieldSig = _emitClassFieldSignature(field, c);
+      var fieldSig = emitClassFieldSignature(field, c);
+      var property = js_ast.Property(memberName, fieldSig);
       // TODO(40273) Skip static fields when the debugger consumes signature
       // information from symbol files.
-      (field.isStatic ? staticFields : instanceFields)
-          .add(js_ast.Property(memberName, fieldSig));
+      (field.isStatic ? staticFields : instanceFields).add(property);
     }
     emitSignature('Field', instanceFields);
     // TODO(40273) Skip for all statics when the debugger consumes signature
     // information from symbol files.
     emitSignature('StaticField', staticFields);
     _classEmittingSignatures = savedClass;
-  }
-
-  js_ast.Expression _emitClassFieldSignature(Field field, Class fromClass) {
-    var fieldType = _typeFromClass(field.type, field.enclosingClass!, fromClass)
-        .extensionTypeErasure;
-    var uri = fieldType is InterfaceType
-        ? _cacheUri(
-            _jsLibraryDebuggerName(fieldType.classNode.enclosingLibrary))
-        : null;
-    var isConst = js.boolean(field.isConst);
-    var isFinal = js.boolean(field.isFinal);
-
-    return uri == null
-        ? js('{type: #, isConst: #, isFinal: #}',
-            [_emitType(fieldType), isConst, isFinal])
-        : js('{type: #, isConst: #, isFinal: #, libraryUri: #}',
-            [_emitType(fieldType), isConst, isFinal, uri]);
+    _currentTypeEnvironment = savedTypeEnvironment;
   }
 
   DartType _memberRuntimeType(Member member, Class fromClass) {
@@ -1828,7 +1814,13 @@
     var savedUri = _currentUri;
     _currentUri = node.fileUri;
     _staticTypeContext.enterMember(node);
-    var params = _emitParameters(node.function);
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    _currentTypeEnvironment =
+        ClassTypeEnvironment(node.enclosingClass.typeParameters);
+
+    var params = <js_ast.Parameter>[];
+    // Generic class constructors accept their RTI as their first argument.
+    params.addAll(_emitParameters(node.function));
     var body = _withCurrentFunction(
         node.function,
         () => _superDisallowed(
@@ -1839,11 +1831,21 @@
     _staticTypeContext.leaveMember(node);
     end ??= _nodeEnd(node.enclosingClass.fileEndOffset);
 
-    return js_ast.Fun(params, js_ast.Block(body))..sourceInformation = end;
+    var constructor = js_ast.Fun([
+      if (_requiresRtiForInstantiation(node.enclosingClass)) _rtiParam,
+      ...params
+    ], js_ast.Block(body))
+      ..sourceInformation = end;
+
+    _currentTypeEnvironment = savedTypeEnvironment;
+    return constructor;
   }
 
   List<js_ast.Statement> _emitConstructorBody(
-      Constructor node, List<Field> fields, js_ast.Expression className) {
+    Constructor node,
+    List<Field> fields,
+    js_ast.Expression className,
+  ) {
     var cls = node.enclosingClass;
 
     // Generate optional/named argument value assignment. These can not have
@@ -1854,6 +1856,20 @@
     var fn = node.function;
     var body = _emitArgumentInitializers(fn, node.name.text);
 
+    // Class instances with type arguments are bound to their RTI on creation.
+    // This must be bound early, as instantiated fields may reference this RTI.
+    if (_requiresRtiForInstantiation(cls)) {
+      // Only set the rti if there isn't one already. This avoids superclasses
+      // overwriting the value already set by a subclass.
+      var rtiProperty = _propertyName(js_ast.FixedNames.rtiName);
+      body.add(js.statement('this.# = this.# || # || #', [
+        rtiProperty,
+        rtiProperty,
+        _rtiParam,
+        _runtimeCall('getReifiedType(this)')
+      ]));
+    }
+
     // Redirecting constructors are not allowed to have conventional
     // initializers but can have variable declarations in the form of
     // initializers to support named arguments appearing anywhere in the
@@ -1869,18 +1885,6 @@
     // 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 (_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.
@@ -1897,17 +1901,46 @@
     return body;
   }
 
-  /// Returns `true` if [cls] or any of its transitive super classes has
-  /// generic type parameters.
-  bool _typeParametersInHierarchy(Class? cls) {
+  /// Returns the "actual" superclass of [c].
+  ///
+  /// Walks up the superclass chain looking for the first actual class
+  /// skipping any synthetic classes inserted by the CFE.
+  Class _superClassAsWritten(Class c) {
+    var superclass = c.superclass!;
+    while (superclass.isAnonymousMixin) {
+      superclass = superclass.superclass!;
+    }
+    return superclass;
+  }
+
+  /// Returns `true` if [cls] requires/accepts an RTI during instantiation.
+  ///
+  /// We check [cls]'s transitive super classes for generic type parameters,
+  /// but we do not consider anonymous mixins, implemented types or mixin on
+  /// clauses - as their constructors are never invoked via super calls.
+  /// Synthetic mixins are also skipped (despite sometimes having type
+  /// parameters) since they can't be referenced during instantiation.
+  ///
+  /// Context: type arguments must be provided to a generic class during its
+  /// instantiation. To avoid extraneous RTI evals, we pass the entire class's
+  /// RTI instead of each type parameter's RTI individually. RTIs are attached
+  /// to the instance on the hidden '$ti' field (see: FixedNames.rtiName). We
+  /// attach RTIs eagerly (i.e., closer to the 'leaf' than the 'root') for
+  /// simplicity. Setters on 'this' propagate up super calls since Dart super
+  /// calls are synthetic. Ordinary JS super calls would require us to
+  /// propagate the RTI all the way to the 'uppermost' generic class.
+  bool _requiresRtiForInstantiation(Class? cls) {
     if (cls == null) return false;
-    var cachedResult = _typeParametersInHierarchyCache[cls];
+    var cachedResult = _requiresRtiForInstantiationCache[cls];
     if (cachedResult != null) return cachedResult;
+    // Skip synthetic mixins since their RTIs are never needed during
+    // instantiation.
+    if (cls.isAnonymousMixin) {
+      cls = _superClassAsWritten(cls);
+    }
     var hasTypeParameters = cls.typeParameters.isNotEmpty ||
-        (cls.isMixinApplication &&
-            _typeParametersInHierarchy(cls.mixedInClass)) ||
-        _typeParametersInHierarchy(cls.superclass);
-    _typeParametersInHierarchyCache[cls] = hasTypeParameters;
+        _requiresRtiForInstantiation(cls.superclass);
+    _requiresRtiForInstantiationCache[cls] = hasTypeParameters;
     return hasTypeParameters;
   }
 
@@ -1921,21 +1954,29 @@
 
   js_ast.Statement _emitRedirectingConstructor(
       List<Initializer> initializers, js_ast.Expression className) {
-    var jsInitializers = <js_ast.Statement>[
-      for (var init in initializers)
-        if (init is LocalInitializer)
-          // Temporary locals are created when named arguments don't appear at
-          // the end of the arguments list.
-          visitVariableDeclaration(init.variable)
-        else if (init is RedirectingInitializer)
-          // We can't dispatch to the constructor with `this.new` as that might
-          // hit a derived class constructor with the same name.
-          js.statement('#.#.call(this, #);', [
-            className,
-            _constructorName(init.target.name.text),
-            _emitArgumentList(init.arguments, types: false)
-          ])
-    ];
+    var jsInitializers = <js_ast.Statement>[];
+    for (var init in initializers) {
+      if (init is LocalInitializer) {
+        // Temporary locals are created when named arguments don't appear at
+        // the end of the arguments list.
+        jsInitializers.add(visitVariableDeclaration(init.variable));
+      } else if (init is RedirectingInitializer) {
+        var rtiParam = _requiresRtiForInstantiation(init.target.enclosingClass)
+            ? _rtiParam
+            : null;
+        // We can't dispatch to the constructor with `this.new` as that might
+        // hit a derived class constructor with the same name.
+        var initializer = js.statement('#.#.call(this, #);', [
+          className,
+          _constructorName(init.target.name.text),
+          [
+            if (rtiParam != null) rtiParam,
+            ..._emitArgumentList(init.arguments, types: false)
+          ]
+        ]);
+        jsInitializers.add(initializer);
+      }
+    }
     return js_ast.Block(jsInitializers);
   }
 
@@ -1950,7 +1991,19 @@
       args = [];
     } else {
       ctor = superInit.target;
-      args = _emitArgumentList(superInit.arguments, types: false);
+      var savedTypeEnvironment = _currentTypeEnvironment;
+      _currentTypeEnvironment = ClassTypeEnvironment(c.typeParameters);
+      // An RTI will already have been set at the constructor call site, so
+      // pass nothing if the superclass is expecting an RTI.
+      var rti = _requiresRtiForInstantiation(ctor.enclosingClass)
+          ? js_ast.LiteralNull()
+          : null;
+      args = [
+        if (rti != null) rti,
+        ..._emitArgumentList(superInit.arguments, types: true)
+      ];
+
+      _currentTypeEnvironment = savedTypeEnvironment;
     }
     // We can skip the super call if it's empty. Most commonly this happens for
     // things that extend Object, and don't have any field initializers or their
@@ -1958,10 +2011,10 @@
     if (ctor.name.text == '' && !_hasUnnamedSuperConstructor(c)) {
       return null;
     }
-    return _emitSuperConstructorCall(className, ctor.name.text, args);
+    return _emitSuperConstructorCall(ctor, className, ctor.name.text, args);
   }
 
-  js_ast.Statement _emitSuperConstructorCall(
+  js_ast.Statement _emitSuperConstructorCall(Constructor constructor,
       js_ast.Expression className, String name, List<js_ast.Expression> args) {
     return js.statement('#.#.call(this, #);', [
       _emitJSObjectGetPrototypeOf(className, fullyQualifiedName: true),
@@ -2381,7 +2434,6 @@
   /// Emits a Dart factory constructor to a JS static method.
   js_ast.Method? _emitFactoryConstructor(Procedure node) {
     if (node.isExternal || isUnsupportedFactoryConstructor(node)) return null;
-
     var function = node.function;
 
     /// Note: factory constructors can't use `sync*`/`async*`/`async` bodies
@@ -2395,8 +2447,10 @@
     /// [_emitFunction] instead.
     var name = node.name.text;
     var savedTypeEnvironment = _currentTypeEnvironment;
-    _currentTypeEnvironment =
-        _currentTypeEnvironment.extend(function.typeParameters);
+    _currentTypeEnvironment = RtiTypeEnvironment([
+      ...function.typeParameters,
+      ..._currentTypeEnvironment.classTypeParameters
+    ]);
     var jsBody = js_ast.Block(_withCurrentFunction(function, () {
       var block = _emitArgumentInitializers(function, name);
       block.add(_emitFunctionScopedBody(function));
@@ -2404,11 +2458,21 @@
     }));
     var jsName = _constructorName(name);
     memberNames[node] = jsName.valueWithoutQuotes;
-    var jsParams = _emitParameters(function);
-    _currentTypeEnvironment = savedTypeEnvironment;
 
-    return js_ast.Method(jsName, js_ast.Fun(jsParams, jsBody), isStatic: true)
-      ..sourceInformation = _nodeEnd(node.fileEndOffset);
+    // Generic class constructors accept their RTI as their first argument.
+    var method = js_ast.Method(
+      jsName,
+      js_ast.Fun(
+        [
+          if (_requiresRtiForInstantiation(node.enclosingClass)) _rtiParam,
+          ..._emitParameters(function)
+        ],
+        jsBody,
+      ),
+      isStatic: true,
+    )..sourceInformation = _nodeEnd(node.fileEndOffset);
+    _currentTypeEnvironment = savedTypeEnvironment;
+    return method;
   }
 
   /// Emits the expression necessary to access a constructor of [type];
@@ -2944,11 +3008,6 @@
         _emitTopLevelMemberName(n, suffix: suffix));
   }
 
-  js_ast.PropertyAccess _emitFutureOrNameNoInterop({String suffix = ''}) {
-    return js_ast.PropertyAccess(_emitLibraryName(_coreTypes.asyncLibrary),
-        _propertyName('FutureOr$suffix'));
-  }
-
   /// Emits the member name portion of a top-level member.
   ///
   /// NOTE: usually you should use [_emitTopLevelName] instead of this. This
@@ -3226,7 +3285,15 @@
 
   /// Returns an expression that evaluates to the rti object from the dart:_rti
   /// library that represents [type].
-  js_ast.Expression _emitType(DartType type) {
+  ///
+  /// [emitJSInteropGenericClassTypeParametersAsAny] indicates that we should
+  /// emit the statically declared type as a JS interop generic class's type
+  /// argument (rather than substituting Any). Any is required for correctness
+  /// in most cases except for uses in non-external JS interop factories.
+  /// Note: This only applies to the old style package:js interop and isn't
+  /// necessary for any forms of static JS interop.
+  js_ast.Expression _emitType(DartType type,
+      {bool emitJSInteropGenericClassTypeParametersAsAny = true}) {
     /// Returns an expression that evaluates a type [recipe] within the type
     /// [environment].
     ///
@@ -3254,64 +3321,68 @@
     /// [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);
-          // 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.
-          env = emitRtiEval(_emitTypeParameter(environmentTypes.first), '@<0>');
-          // Bind remaining type arguments.
-          for (var i = 1; i < environmentTypes.length; i++) {
-            env = emitRtiBind(env, environmentTypes[i]);
+      switch (environment) {
+        case EmptyTypeEnvironment():
+          return js
+              .call('#._Universe.eval(#._theUniverse(), "$recipe", true)', [
+            _emitLibraryName(_rtiLibrary),
+            _emitLibraryName(_rtiLibrary),
+          ]);
+        case 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.functionTypeParameters.single);
+            // Skip a no-op evaluation and just return the parameter.
+            if (recipe == '0') return env;
+          } else {
+            var environmentTypes = environment.functionTypeParameters;
+            // 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.
-        var env = _runtimeCall('getReifiedType(this)');
-        return emitRtiEval(env, recipe);
-      } else if (environment is ExtendedClassTypeEnvironment) {
-        // A generic class instance already stores a reference to a type
-        // containing all of its type arguments.
-        var env = _runtimeCall('getReifiedType(this)');
-        // 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}).');
+          return emitRtiEval(env, recipe);
+        case RtiTypeEnvironment():
+          // RTI type environments are already constructed and attached to the
+          // provided RTI.
+          var env = _rtiParam;
+          return emitRtiEval(env, recipe);
+        case ClassTypeEnvironment():
+          // Class type environments are already constructed and attached to the
+          // instance of a generic class.
+          var env =
+              js.call('#.instanceType(this)', [_emitLibraryName(_rtiLibrary)]);
+          return emitRtiEval(env, recipe);
+        case ExtendedClassTypeEnvironment():
+          // Class type environments are already constructed and attached to the
+          // instance of a generic class, but function type parameters need to
+          // be bound.
+          var env =
+              js.call('#.instanceType(this)', [_emitLibraryName(_rtiLibrary)]);
+          // Bind extra type parameters.
+          for (var parameter in environment.functionTypeParameters) {
+            env = emitRtiBind(env, parameter);
+          }
+          return emitRtiEval(env, recipe);
       }
+      _typeCompilationError(type,
+          'Unexpected DDCTypeEnvironment type (${environment.runtimeType}).');
     }
 
     var normalizedType =
         _futureOrNormalizer.normalize(type.extensionTypeErasure);
     try {
       var result = _typeRecipeGenerator.recipeInEnvironment(
-          normalizedType, _currentTypeEnvironment);
+          normalizedType, _currentTypeEnvironment,
+          emitJSInteropGenericClassTypeParametersAsAny:
+              emitJSInteropGenericClassTypeParametersAsAny);
       var typeRep =
           evalInEnvironment(result.requiredEnvironment, result.recipe);
-      if (_cacheTypes &&
-          // Avoid adding a the use of a single type parameter to the type
-          // table. These can be referenced directly because the are already
-          // represented as a local variable in the scope.
-          !(normalizedType is TypeParameterType &&
-                  normalizedType.isPotentiallyNonNullable ||
-              normalizedType is StructuralParameterType &&
-                  normalizedType.isPotentiallyNullable)) {
-        typeRep = _typeTable.nameType(normalizedType, typeRep);
-      }
       return typeRep;
     } on UnsupportedError catch (e) {
       _typeCompilationError(normalizedType, e.message ?? 'Unknown Error');
@@ -3329,10 +3400,8 @@
   /// The nullability of [type] is not considered because it is meaningless when
   /// describing a reference to the class itself.
   ///
-  /// In the case of a generic type, this reference will be a call to the
-  /// function that defines the class and will pass the type parameters as
-  /// arguments. The nullability of the type parameters does have meaning so it
-  /// is encoded.
+  /// For generic classes, type arguments are not needed since they are
+  /// resolved late via an RTI lookup.
   ///
   /// Note that for `package:js` types, this will emit the class we emitted
   /// using `_emitJSInteropClassNonExternalMembers`, and not the runtime type
@@ -3340,14 +3409,9 @@
   js_ast.Expression _emitClassRef(InterfaceType type) {
     var cls = type.classNode;
     _declareBeforeUse(cls);
-    var args = type.typeArguments;
-    Iterable<js_ast.Expression>? jsArgs;
-    if (args.any((a) => a != const DynamicType())) {
-      jsArgs = args.map(_emitType);
-    }
-    if (jsArgs != null) {
-      return _genericClassTable.nameType(
-          type, _emitGenericClassType(type, jsArgs));
+    if (!_emittingClassExtends && type.typeArguments.isNotEmpty) {
+      var genericName = _emitTopLevelNameNoExternalInterop(type.classNode);
+      return js.call('#', [genericName]);
     }
     return _emitTopLevelNameNoExternalInterop(type.classNode);
   }
@@ -3359,15 +3423,6 @@
   bool get _emittingClassExtends =>
       _currentClass != null && identical(_currentClass, _classEmittingExtends);
 
-  bool get _cacheTypes => !_emittingDeferredType && !_emittingClassExtends;
-
-  js_ast.Expression _emitGenericClassType(
-      InterfaceType t, Iterable<js_ast.Expression> typeArgs) {
-    var genericName =
-        _emitTopLevelNameNoExternalInterop(t.classNode, suffix: '\$');
-    return js.call('#(#)', [genericName, typeArgs]);
-  }
-
   /// Emits an expression that lets you access statics on a [type] from code.
   js_ast.Expression _emitConstructorName(InterfaceType type, Member c) {
     var isSyntheticDefault =
@@ -3445,6 +3500,11 @@
     _currentLibrary = library;
     _staticTypeContext.enterLibrary(_currentLibrary!);
     _currentClass = cls;
+    // Generic parameters should be evaluated in a class environment if
+    // provided. Otherwise we default to an empty type environment.
+    if (cls != null) {
+      _currentTypeEnvironment = ClassTypeEnvironment(cls.typeParameters);
+    }
 
     // Keep all symbols in containers.
     _containerizeSymbols = true;
@@ -3504,7 +3564,10 @@
   js_ast.Fun _emitFunction(FunctionNode f, String? name,
       {SourceLocation? functionEnd, SourceLocation? functionBody}) {
     var savedTypeEnvironment = _currentTypeEnvironment;
-    _currentTypeEnvironment = _currentTypeEnvironment.extend(f.typeParameters);
+    if (f.typeParameters.isNotEmpty) {
+      _currentTypeEnvironment =
+          _currentTypeEnvironment.extend(f.typeParameters);
+    }
     var formals = _emitParameters(f);
     var typeFormals = _emitTypeFormals(f.typeParameters);
 
@@ -4482,12 +4545,13 @@
     // full desugaring seems okay.
     var streamIterator = _coreTypes.rawType(
         _asyncStreamIteratorClass, _currentLibrary!.nonNullable);
+    var streamIteratorRti = _emitType(streamIterator);
     var createStreamIter = js_ast.Call(
         _emitConstructorName(
             streamIterator,
             _asyncStreamIteratorClass.procedures
                 .firstWhere((p) => p.isFactory && p.name.text == '')),
-        [_visitExpression(node.iterable)]);
+        [streamIteratorRti, _visitExpression(node.iterable)]);
 
     var iter = _emitTemporaryId('iter');
 
@@ -6107,27 +6171,14 @@
         // Serves as a way to access the wrapped JS exception.
         return _emitVariableRef(_rethrowParameter!);
       }
+      if (name == 'JS_RTI_PARAMETER') {
+        return _rtiParam;
+      }
     }
 
     if (_isSdkInternalRuntime(enclosingLibrary)) {
       var name = target.name.text;
-      if (node.arguments.positional.isEmpty &&
-          node.arguments.types.length == 1) {
-        var type = node.arguments.types.single;
-        if (name == 'getGenericClassStatic') {
-          if (type is InterfaceType) {
-            return _emitTopLevelNameNoExternalInterop(type.classNode,
-                suffix: '\$');
-          }
-          if (type is FutureOrType) {
-            return _emitFutureOrNameNoInterop(suffix: '\$');
-          } else {
-            throw UnsupportedError(
-                '`getGenericClassStatic` Unsupported type found: '
-                '$type (${type.runtimeType}) at ${node.location}');
-          }
-        }
-      } else if (node.arguments.positional.length == 1) {
+      if (node.arguments.positional.length == 1) {
         var firstArg = node.arguments.positional.single;
         if (name == 'extensionSymbol' && firstArg is StringLiteral) {
           return _getSymbol(_getExtensionSymbolInternal(firstArg.value));
@@ -6546,15 +6597,30 @@
         js_ast.Call(_emitTopLevelName(_coreTypes.identicalProcedure), jsArgs));
   }
 
+  /// Returns true if this [member] is a JS interop member.
+  bool isJSInteropMember(Member member) =>
+      member.isExternal && hasJSInteropAnnotation(member.enclosingClass!);
+
   @override
   js_ast.Expression visitConstructorInvocation(ConstructorInvocation node) {
     var ctor = node.target;
     var ctorClass = ctor.enclosingClass;
     var args = node.arguments;
     if (isJSAnonymousType(ctorClass)) return _emitObjectLiteral(args, ctor);
-    var result = js_ast.New(_emitConstructorName(node.constructedType, ctor),
-        _emitArgumentList(args, types: false, target: ctor));
-
+    // JS interop constructor calls do not provide an RTI at the call site.
+    var shouldProvideRti =
+        !isJSInteropMember(ctor) && _requiresRtiForInstantiation(ctorClass);
+    var rti = shouldProvideRti
+        ? _emitType(node.constructedType,
+            emitJSInteropGenericClassTypeParametersAsAny: false)
+        : null;
+    var result = js_ast.New(
+      _emitConstructorName(node.constructedType, ctor),
+      [
+        if (rti != null) rti,
+        ..._emitArgumentList(args, types: false, target: ctor)
+      ],
+    );
     return node.isConst ? _canonicalizeConstObject(result) : result;
   }
 
@@ -6562,7 +6628,8 @@
     var args = node.arguments;
     var ctor = node.target;
     var ctorClass = ctor.enclosingClass!;
-    if (ctor.isExternal && hasJSInteropAnnotation(ctorClass)) {
+    // JS interop constructor calls do not require an RTI at the call site.
+    if (isJSInteropMember(ctor)) {
       return _emitJSInteropNew(ctor, args);
     }
 
@@ -6586,20 +6653,30 @@
         case 'HashMap':
         case 'LinkedHashMap':
           if (ctor.name.text == '') {
-            return js.call('new #.new()', _emitMapImplType(type));
+            var mapType = _createMapImplType(type);
+            var mapClass = _emitClassRef(mapType);
+            var rti = _emitType(mapType);
+            return js.call('new #.new(#)', [mapClass, rti]);
           } else if (ctor.name.text == 'identity') {
-            return js.call(
-                'new #.new()', _emitMapImplType(type, identity: true));
+            var mapType = _createMapImplType(type, identity: true);
+            var mapClass = _emitClassRef(mapType);
+            var rti = _emitType(mapType);
+            return js.call('new #.new(#)', [mapClass, rti]);
           }
           break;
         case 'Set':
         case 'HashSet':
         case 'LinkedHashSet':
           if (ctor.name.text == '') {
-            return js.call('new #.new()', _emitSetImplType(type));
+            var setType = _createSetImplType(type);
+            var setClass = _emitClassRef(setType);
+            var rti = _emitType(setType);
+            return js.call('new #.new(#)', [setClass, rti]);
           } else if (ctor.name.text == 'identity') {
-            return js.call(
-                'new #.new()', _emitSetImplType(type, identity: true));
+            var setType = _createSetImplType(type, identity: true);
+            var setClass = _emitClassRef(setType);
+            var rti = _emitType(setType);
+            return js.call('new #.new(#)', [setClass, rti]);
           }
           break;
         case 'List':
@@ -6609,39 +6686,41 @@
           break;
       }
     }
-
+    var rti = _requiresRtiForInstantiation(ctorClass)
+        ? _emitType(type, emitJSInteropGenericClassTypeParametersAsAny: false)
+        : null;
     var result = js_ast.Call(_emitConstructorName(type, ctor),
-        _emitArgumentList(args, types: false));
-
+        [if (rti != null) rti, ..._emitArgumentList(args, types: false)]);
     return node.isConst ? _canonicalizeConstObject(result) : result;
   }
 
   js_ast.Expression _emitJSInteropNew(Member ctor, Arguments args) {
     var ctorClass = ctor.enclosingClass!;
     if (isJSAnonymousType(ctorClass)) return _emitObjectLiteral(args, ctor);
+    // JS interop constructor calls do not require an RTI at the call site.
     return js_ast.New(
         _emitConstructorName(_coreTypes.nonNullableRawType(ctorClass), ctor),
         _emitArgumentList(args, types: false, target: ctor));
   }
 
-  js_ast.Expression _emitMapImplType(InterfaceType type, {bool? identity}) {
+  InterfaceType _createMapImplType(InterfaceType type, {bool? identity}) {
     var typeArgs = type.typeArguments;
     if (typeArgs.isEmpty) {
-      return _emitClassRef(type);
+      return type.withDeclaredNullability(Nullability.nonNullable);
     }
     identity ??= _typeRep.isPrimitive(typeArgs[0]);
     var c = identity ? _identityHashMapImplClass : _linkedHashMapImplClass;
-    return _emitClassRef(InterfaceType(c, Nullability.nonNullable, typeArgs));
+    return InterfaceType(c, Nullability.nonNullable, typeArgs);
   }
 
-  js_ast.Expression _emitSetImplType(InterfaceType type, {bool? identity}) {
+  InterfaceType _createSetImplType(InterfaceType type, {bool? identity}) {
     var typeArgs = type.typeArguments;
     if (typeArgs.isEmpty) {
-      return _emitClassRef(type);
+      return type.withDeclaredNullability(Nullability.nonNullable);
     }
     identity ??= _typeRep.isPrimitive(typeArgs[0]);
     var c = identity ? _identityHashSetImplClass : _linkedHashSetImplClass;
-    return _emitClassRef(InterfaceType(c, Nullability.nonNullable, typeArgs));
+    return InterfaceType(c, Nullability.nonNullable, typeArgs);
   }
 
   js_ast.Expression _emitObjectLiteral(Arguments node, Member ctor) {
@@ -6945,15 +7024,15 @@
       DartType itemType, List<js_ast.Expression> items) {
     var list = js_ast.ArrayInitializer(items);
 
-    // TODO(jmesserly): analyzer will usually infer `List<Object>` because
-    // that is the least upper bound of the element types. So we rarely
-    // generate a plain `List<dynamic>` anymore.
+    // List's type parameter is default-initialized to dynamic in our runtime.
     if (itemType == const DynamicType()) return list;
 
     // Call `new JSArray<E>.of(list)`
-    var arrayType = _emitClassRef(
-        InterfaceType(_jsArrayClass, Nullability.nonNullable, [itemType]));
-    return js.call('#.of(#)', [arrayType, list]);
+    var type =
+        InterfaceType(_jsArrayClass, Nullability.nonNullable, [itemType]);
+    var arrayClass = _emitClassRef(type);
+    var arrayRti = _emitType(type);
+    return js.call('#.of(#, #)', [arrayClass, arrayRti, list]);
   }
 
   js_ast.Expression _emitConstList(
@@ -6961,20 +7040,22 @@
     // dart.constList helper internally depends on _interceptors.JSArray.
     _declareBeforeUse(_jsArrayClass);
     return _runtimeCall(
-        'constList([#], #)', [elements, _emitType(elementType)]);
+        'constList(#, [#])', [_emitType(elementType), elements]);
   }
 
   @override
   js_ast.Expression visitSetLiteral(SetLiteral node) {
     // TODO(markzipan): remove const check when we use front-end const eval
     if (!node.isConst) {
-      var setType = _emitClassRef(InterfaceType(
-          _linkedHashSetClass, Nullability.nonNullable, [node.typeArgument]));
+      var type = InterfaceType(
+          _linkedHashSetClass, Nullability.nonNullable, [node.typeArgument]);
+      var setClass = _emitClassRef(type);
+      var rti = _emitType(type);
       if (node.expressions.isEmpty) {
-        return js.call('#.new()', [setType]);
+        return js.call('#.new(#)', [setClass, rti]);
       }
-      return js.call(
-          '#.from([#])', [setType, _visitExpressionList(node.expressions)]);
+      return js.call('#.from(#, [#])',
+          [setClass, rti, _visitExpressionList(node.expressions)]);
     }
     return _emitConstSet(
         node.typeArgument, _visitExpressionList(node.expressions));
@@ -6996,12 +7077,14 @@
 
     // TODO(markzipan): remove const check when we use front-end const eval
     if (!node.isConst) {
-      var mapType = _emitMapImplType(
-          node.getStaticType(_staticTypeContext) as InterfaceType);
+      var type = node.getStaticType(_staticTypeContext) as InterfaceType;
+      var mapType = _createMapImplType(type);
+      var mapClass = _emitClassRef(mapType);
+      var rti = _emitType(mapType);
       if (node.entries.isEmpty) {
-        return js.call('new #.new()', [mapType]);
+        return js.call('new #.new(#)', [mapClass, rti]);
       }
-      return js.call('new #.from([#])', [mapType, entries]);
+      return js.call('new #.from(#, [#])', [mapClass, rti, entries]);
     }
     return _emitConstMap(node.keyType, node.valueType, entries);
   }
@@ -7419,6 +7502,12 @@
   @override
   js_ast.Expression visitInstanceConstant(InstanceConstant node) {
     _declareBeforeUse(node.classNode);
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    if (node.classNode.typeParameters.isNotEmpty) {
+      _currentTypeEnvironment =
+          ClassTypeEnvironment(node.classNode.typeParameters);
+    }
+
     js_ast.Property entryToProperty(MapEntry<Reference, Constant> entry) {
       var constant = visitConstant(entry.value);
       var member = entry.key.asField;
@@ -7449,9 +7538,11 @@
       for (var e in node.fieldValues.entries.toList().reversed)
         entryToProperty(e),
     ];
-    return _canonicalizeConstObject(_emitJSObjectSetPrototypeOf(
+    var constant = _canonicalizeConstObject(_emitJSObjectSetPrototypeOf(
         js_ast.ObjectInitializer(properties, multiline: true), prototype,
         fullyQualifiedName: false));
+    _currentTypeEnvironment = savedTypeEnvironment;
+    return constant;
   }
 
   /// Emits a private name JS Symbol for [member] unique to a Dart class
@@ -7665,7 +7756,7 @@
   ///
   /// For example:
   ///
-  ///     runtimeCall('asInt(#)', [<expr>])
+  ///     _runtimeCall('asInt(#)', [<expr>])
   ///
   /// Generates a JS AST representing:
   ///
@@ -8096,8 +8187,8 @@
   ///
   /// The [moduleName] should specify the module's name, and the items should
   /// be the list resulting from startModule, with additional items added,
-  /// but not including the contents of moduleItems (which will be handled by
-  /// this method itself).
+  /// but not including the contents of [_moduleItems] (which will be handled
+  /// by this method itself).
   ///
   /// Note, this function mutates the items list and returns it as the `body`
   /// field of the result.
diff --git a/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart b/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart
index a109325..6e2c53b 100644
--- a/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart
+++ b/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart
@@ -45,15 +45,9 @@
 ///
 /// The caller of this function has to make sure that this name is unique in
 /// the current scope.
-///
-/// In the current encoding, generic classes are generated in a function scope
-/// which avoids name clashes of the escaped class name.
 String getLocalClassName(Class node) => escapeIdentifier(node.name);
 
 /// Returns the escaped name for the type parameter [node].
-///
-/// In the current encoding, generic classes are generated in a function scope
-/// which avoids name clashes of the escaped parameter name.
 String getTypeParameterName(
     /* TypeParameter | StructuralParameter */ Object node) {
   assert(node is TypeParameter || node is StructuralParameter);
diff --git a/pkg/dev_compiler/lib/src/kernel/type_environment.dart b/pkg/dev_compiler/lib/src/kernel/type_environment.dart
index e3185b8..64ea536 100644
--- a/pkg/dev_compiler/lib/src/kernel/type_environment.dart
+++ b/pkg/dev_compiler/lib/src/kernel/type_environment.dart
@@ -23,6 +23,30 @@
   /// Returns the index of [parameter] in this environment for use in a type
   /// recipe or a negative value if the parameter was not found.
   int recipeIndexOf(TypeParameter parameter);
+
+  /// Returns all class type parameters in this type environment.
+  ///
+  /// For the example:
+  /// Class Foo<T> {
+  ///   method<U> {
+  ///     ... // this
+  ///   }
+  /// }
+  ///
+  /// classTypeParameters in this would return ['T'].
+  List<TypeParameter> get classTypeParameters;
+
+  /// Returns all class type parameters in this type environment.
+  ///
+  /// For the example:
+  /// Class Foo<T> {
+  ///   method<U> {
+  ///     ... // this
+  ///   }
+  /// }
+  ///
+  /// functionTypeParameters this would return ['U'].
+  List<TypeParameter> get functionTypeParameters;
 }
 
 /// An empty environment that signals no type parameters are present or needed.
@@ -45,6 +69,12 @@
   int recipeIndexOf(TypeParameter parameter) {
     return -1;
   }
+
+  @override
+  List<TypeParameter> get classTypeParameters => UnmodifiableListView([]);
+
+  @override
+  List<TypeParameter> get functionTypeParameters => UnmodifiableListView([]);
 }
 
 /// A type environment introduced by a class with one or more generic type
@@ -78,6 +108,54 @@
     // class rti with all type arguments.
     return i + 1;
   }
+
+  @override
+  List<TypeParameter> get classTypeParameters =>
+      UnmodifiableListView(_typeParameters);
+
+  @override
+  List<TypeParameter> get functionTypeParameters => UnmodifiableListView([]);
+}
+
+/// A type environment introduced by a subroutine, wherein an RTI object is
+/// explicitly provided.
+class RtiTypeEnvironment implements DDCTypeEnvironment {
+  final List<TypeParameter> _typeParameters;
+
+  RtiTypeEnvironment(this._typeParameters);
+
+  @override
+  DDCTypeEnvironment extend(List<TypeParameter> parameters) {
+    /// RtiTypeEnvironments are only used for constructors, factories, and type
+    /// signatures - none of which can accept generic arguments.
+    throw Exception(
+        'RtiTypeEnvironments should not receive extended type parameters.');
+  }
+
+  @override
+  DDCTypeEnvironment prune(Iterable<TypeParameter> requiredParameters) {
+    // If any parameters are required, the class type environment already
+    // exists and a reference to it is suitably compact.
+    return requiredParameters.any(_typeParameters.contains)
+        ? this
+        : const EmptyTypeEnvironment();
+  }
+
+  @override
+  int recipeIndexOf(TypeParameter parameter) {
+    var i = _typeParameters.indexOf(parameter);
+    if (i < 0) return i;
+    // Index for class type parameters is one based. Zero refers to the full
+    // class rti with all type arguments.
+    return i + 1;
+  }
+
+  @override
+  List<TypeParameter> get classTypeParameters =>
+      UnmodifiableListView(_typeParameters);
+
+  @override
+  List<TypeParameter> get functionTypeParameters => UnmodifiableListView([]);
 }
 
 /// A type environment containing multiple type parameters.
@@ -115,8 +193,12 @@
     return i + 1;
   }
 
-  /// The type parameters in this environment.
-  List<TypeParameter> get parameters => UnmodifiableListView(_typeParameters);
+  @override
+  List<TypeParameter> get classTypeParameters => UnmodifiableListView([]);
+
+  @override
+  List<TypeParameter> get functionTypeParameters =>
+      UnmodifiableListView(_typeParameters);
 
   /// Returns `true` if this environment only contains a single type parameter.
   bool get isSingleTypeParameter => _typeParameters.length == 1;
@@ -155,10 +237,6 @@
           // No type parameters are needed from this environment.
           : const EmptyTypeEnvironment();
     }
-    if (!classEnvironmentNeeded) {
-      // None of the parameters are needed from the class environment.
-      return BindingTypeEnvironment(additionalParameters.toList());
-    }
     // This is already the exact environment needed.
     if (additionalParameters.length == _typeParameters.length) return this;
     // An extended class environment with fewer additional parameters is needed.
@@ -183,6 +261,11 @@
     return -1;
   }
 
-  List<TypeParameter> get extendedParameters =>
+  @override
+  List<TypeParameter> get classTypeParameters =>
+      UnmodifiableListView(_classEnvironment.classTypeParameters);
+
+  @override
+  List<TypeParameter> get functionTypeParameters =>
       UnmodifiableListView(_typeParameters);
 }
diff --git a/pkg/dev_compiler/lib/src/kernel/type_recipe_generator.dart b/pkg/dev_compiler/lib/src/kernel/type_recipe_generator.dart
index 384707b..3f8cd6b 100644
--- a/pkg/dev_compiler/lib/src/kernel/type_recipe_generator.dart
+++ b/pkg/dev_compiler/lib/src/kernel/type_recipe_generator.dart
@@ -43,14 +43,19 @@
   /// The returned environment will be a subset of the provided [environment]
   /// that includes only the necessary types to evaluate the recipe.
   GeneratedRecipe recipeInEnvironment(
-      DartType type, DDCTypeEnvironment environment) {
+      DartType type, DDCTypeEnvironment environment,
+      {bool emitJSInteropGenericClassTypeParametersAsAny = true}) {
     // Reduce the provided environment down to the parameters that are present.
     var parametersInType = TypeParameterFinder.instance().find(type);
     var minimalEnvironment = environment.prune(parametersInType);
     // Set the visitor state, generate the recipe, and package it with the
     // environment required to evaluate it.
     _recipeVisitor.setState(
-        environment: minimalEnvironment, addLiveInterfaceTypes: true);
+      environment: minimalEnvironment,
+      addLiveInterfaceTypes: true,
+      emitJSInteropGenericClassTypeParametersAsAny:
+          emitJSInteropGenericClassTypeParametersAsAny,
+    );
     var recipe = type.accept(_recipeVisitor);
     return GeneratedRecipe(recipe, minimalEnvironment);
   }
@@ -124,7 +129,8 @@
           environment: ClassTypeEnvironment(cls.typeParameters),
           // No need to add any more live types at this time. Any "new" types
           // seen in this process are not live.
-          addLiveInterfaceTypes: false);
+          addLiveInterfaceTypes: false,
+          emitClassTypeParametersAsIndices: true);
       var supertypeEntries = <String, Object>{};
       // Encode the type argument mapping portion of this type rule.
       for (var i = 0; i < cls.typeParameters.length; i++) {
@@ -258,6 +264,24 @@
   /// all of the visited interface types.
   bool _addLiveInterfaceTypes = true;
 
+  /// When `true`, references generic class type parameters via their de Bruijn
+  /// indices.
+  ///
+  /// DDC defaults to using generic parameter names instead of de Bruijn
+  /// indices because the latter aren't stable across subtype environments.
+  ///
+  /// This is only used when generating type rules for the type universe
+  /// (i.e., in `liveInterfaceTypeRules`).
+  bool _emitClassTypeParametersAsIndices = false;
+
+  /// Emits JS interop generic arguments as `Any` when true and their 'real'
+  /// type when false.
+  ///
+  /// We usually convert type arguments to `Any` to allow type checks and casts
+  /// to succeed for JS interop objects. However, their 'real' types are used
+  /// for checks in non-external constructors and factories.
+  bool _emitJSInteropGenericClassTypeParametersAsAny = true;
+
   /// All of the [InterfaceType]s visited.
   final _visitedInterfaceTypes = <InterfaceType>{};
   final _visitedJsInteropTypes = <InterfaceType>{};
@@ -270,12 +294,23 @@
   /// Generally this should be called before visiting a type, but the visitor
   /// does not modify the state so if many types need to be evaluated in the
   /// same state it can be set once before visiting all of them.
-  void setState(
-      {DDCTypeEnvironment? environment, bool? addLiveInterfaceTypes}) {
+  void setState({
+    DDCTypeEnvironment? environment,
+    bool? addLiveInterfaceTypes,
+    bool? emitClassTypeParametersAsIndices,
+    bool? emitJSInteropGenericClassTypeParametersAsAny,
+  }) {
     if (environment != null) _typeEnvironment = environment;
     if (addLiveInterfaceTypes != null) {
       _addLiveInterfaceTypes = addLiveInterfaceTypes;
     }
+    if (emitClassTypeParametersAsIndices != null) {
+      _emitClassTypeParametersAsIndices = emitClassTypeParametersAsIndices;
+    }
+    if (emitJSInteropGenericClassTypeParametersAsAny != null) {
+      _emitJSInteropGenericClassTypeParametersAsAny =
+          emitJSInteropGenericClassTypeParametersAsAny;
+    }
   }
 
   /// The [InterfaceType]s that have been visited.
@@ -312,7 +347,8 @@
     var recipeBuffer = StringBuffer(interfaceTypeRecipe(cls));
     // Generate the recipes for all type arguments.
     if (node.typeArguments.isNotEmpty) {
-      var argumentRecipes = hasJSInteropAnnotation(cls)
+      var argumentRecipes = _emitJSInteropGenericClassTypeParametersAsAny &&
+              hasJSInteropAnnotation(cls)
           ? _listOfJSAnyType(node.typeArguments.length)
           : node.typeArguments.map((typeArgument) => typeArgument.accept(this));
       recipeBuffer.write(Recipe.startTypeArgumentsString);
@@ -433,6 +469,26 @@
           '${Recipe.genericFunctionTypeParameterIndexString}'
           '${_nullabilityRecipe(node)}';
     }
+    var parameterDeclaration = node.parameter.declaration;
+    if (!_emitClassTypeParametersAsIndices && parameterDeclaration is Class) {
+      // Generic type parameters in binding positions will still be emitted
+      // with indices.
+      var typeParamInBindingPosition = _typeEnvironment
+              is BindingTypeEnvironment ||
+          (_typeEnvironment is ExtendedClassTypeEnvironment &&
+              _typeEnvironment.functionTypeParameters.contains(node.parameter));
+      if (!typeParamInBindingPosition) {
+        // We don't emit RTI rules for anonymous mixins since 1) their
+        // generated names are very large and 2) they aren't declared in user
+        // code. However, type parameters that reference them may still appear
+        // (such as for covariant mixin stubs), so we reference them via their
+        // mixin application's subclass.
+        var classNameToEmit = parameterDeclaration.isAnonymousMixin
+            ? parameterDeclaration.nameAsMixinApplicationSubclass
+            : parameterDeclaration.name;
+        return '$classNameToEmit.${node.parameter.name}${_nullabilityRecipe(node)}';
+      }
+    }
     i = _typeEnvironment.recipeIndexOf(node.parameter);
     if (i < 0) {
       throw UnsupportedError(
diff --git a/pkg/dev_compiler/test/expression_compiler/runtime_debugger_api_test.dart b/pkg/dev_compiler/test/expression_compiler/runtime_debugger_api_test.dart
index bf7a04c..5017f33 100644
--- a/pkg/dev_compiler/test/expression_compiler/runtime_debugger_api_test.dart
+++ b/pkg/dev_compiler/test/expression_compiler/runtime_debugger_api_test.dart
@@ -160,7 +160,8 @@
     test('getClassMetadata (object)', () async {
       await driver.checkRuntimeInFrame(
           breakpointId: 'BP',
-          expression: 'dart.getClassMetadata("dart:core", "Object")',
+          expression:
+              'dart.getClassMetadata("dart:core", "Object", {"objectInstance": object})',
           expectedResult: {
             'className': 'Object',
             'fields': {},
@@ -181,7 +182,7 @@
       await driver.checkRuntimeInFrame(
           breakpointId: 'BP',
           expression:
-              'dart.getClassMetadata("package:eval_test/test.dart", "BaseClass")',
+              'dart.getClassMetadata("package:eval_test/test.dart", "BaseClass", {"objectInstance": base})',
           expectedResult: {
             'className': 'BaseClass',
             'superClassName': 'Object',
@@ -243,7 +244,7 @@
       await driver.checkRuntimeInFrame(
           breakpointId: 'BP',
           expression:
-              'dart.getClassMetadata("package:eval_test/test.dart", "DerivedClass")',
+              'dart.getClassMetadata("package:eval_test/test.dart", "DerivedClass", {"objectInstance": derived})',
           expectedResult: {
             'className': 'DerivedClass',
             'superClassName': 'BaseClass',
diff --git a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/classes.dart b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/classes.dart
index dcd20a8..3462510 100644
--- a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/classes.dart
+++ b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/classes.dart
@@ -98,85 +98,8 @@
 
 final mixinOn = JS('', 'Symbol("mixinOn")');
 
-/// The Symbol for storing type arguments on a specialized generic type.
-final _typeArguments = JS('', 'Symbol("typeArguments")');
-
-final _originalDeclaration = JS('', 'Symbol("originalDeclaration")');
-
 final mixinNew = JS('', 'Symbol("dart.mixinNew")');
 
-/// Memoize a generic type constructor function.
-generic(typeConstructor, setBaseClass) => JS('', '''(() => {
-  let length = $typeConstructor.length;
-  if (length < 1) {
-    $throwInternalError('must have at least one generic type argument');
-  }
-  let resultMap = new Map();
-  // TODO(vsm): Rethink how to clear the resultMap on hot restart.
-  // A simple clear via:
-  //   _cacheMaps.push(resultMap);
-  // will break (a) we hoist type expressions in generated code and
-  // (b) we don't clear those type expressions in the presence of a
-  // hot restart.  Not clearing this map (as we're doing now) should
-  // not affect correctness, but can result in a memory leak across
-  // multiple restarts.
-  function makeGenericType(...args) {
-    if (args.length != length && args.length != 0) {
-      $throwInternalError('requires ' + length + ' or 0 type arguments');
-    }
-    while (args.length < length) args.push(${TYPE_REF<dynamic>()});
-
-    let value = resultMap;
-    for (let i = 0; i < length; i++) {
-      let arg = args[i];
-      if (arg == null) {
-        $throwInternalError('type arguments should not be null: '
-                          + $typeConstructor);
-      }
-      let map = value;
-      value = map.get(arg);
-      if (value === void 0) {
-        if (i + 1 == length) {
-          value = $typeConstructor.apply(null, args);
-          // Save the type constructor and arguments for reflection.
-          if (value) {
-            value[$_typeArguments] = args;
-            value[$_originalDeclaration] = makeGenericType;
-          }
-          map.set(arg, value);
-          if ($setBaseClass != null) $setBaseClass.apply(null, args);
-        } else {
-          value = new Map();
-          map.set(arg, value);
-        }
-      }
-    }
-    return value;
-  }
-  makeGenericType[$_genericTypeCtor] = $typeConstructor;
-  return makeGenericType;
-})()''');
-
-getGenericClass(type) => safeGetOwnProperty(type, _originalDeclaration);
-
-/// Extracts the type argument as the accessor for the JS class.
-///
-/// Should be used in place of [getGenericClass] when we know the class we want
-/// statically.
-///
-/// This value is extracted and inlined by the compiler without any runtime
-/// operations. The implementation here is only provided as a theoretical fall
-/// back and shouldn't actually be run.
-///
-/// For example `getGenericClassStatic<FutureOr>` emits `async.FutureOr$`
-/// directly.
-external getGenericClassStatic<T>();
-
-// TODO(markzipan): Make this non-nullable if we can ensure this returns
-// an empty list or if null and the empty list are semantically the same.
-List? getGenericArgs(type) =>
-    JS<List?>('', '#', safeGetOwnProperty(type, _typeArguments));
-
 Object instantiateClass(Object genericClass, List<Object> typeArgs) {
   return JS('', '#.apply(null, #)', genericClass, typeArgs);
 }
@@ -208,8 +131,10 @@
 
 getGenericTypeCtor(value) => JS('', '#[#]', value, _genericTypeCtor);
 
-/// Get the type of an object.
-getType(obj) {
+/// Returns the type signature storage site for [obj].
+///
+/// This is typically an instance's JS constructor.
+getTypeSignatureContainer(obj) {
   if (obj == null) return JS('!', '#', Object);
 
   // Object.create(null) produces a js object without a prototype.
@@ -222,23 +147,13 @@
 getLibraryUri(value) => JS('', '#[#]', value, _libraryUri);
 setLibraryUri(f, uri) => JS('', '#[#] = #', f, _libraryUri, uri);
 
-/// Returns the name of the Dart class represented by [cls] including the
-/// instantiated type arguments.
+/// Returns the name of the Dart class represented by [cls].
 @notNull
 String getClassName(Object? cls) {
   if (cls != null) {
     var tag = JS('', '#[#]', cls, rti.interfaceTypeRecipePropertyName);
     if (tag != null) {
-      var name = JS<String>('!', '#.name', cls);
-      var args = getGenericArgs(cls);
-      if (args == null) return name;
-      var result = name + '<';
-      for (var i = 0; i < JS<int>('!', '#.length', args); ++i) {
-        if (i > 0) result += ', ';
-        result += typeName(JS('', '#[#]', args, i));
-      }
-      result += '>';
-      return result;
+      return JS<String>('!', '#.name', cls);
     }
   }
   return 'unknown (null)';
@@ -270,22 +185,45 @@
   return !_jsInstanceOf(obj, Object);
 }
 
-/// Get the type of a method from a type using the stored signature
-getMethodType(type, name) {
-  var m = getMethods(type);
-  return m != null ? JS('', '#[#]', m, name) : null;
+/// Returns the RTI for an object instance's field or method signature.
+Object? rtiFromSignature(instance, signature) {
+  if (signature == null) return signature;
+  if (JS<bool>('!', 'typeof # == "function"', signature)) {
+    // Signatures for generic types are resolved at runtime. A JS function here
+    // indicates that this signature has not yet been bound to an instance.
+    return JS<Object>('', '#(#)', signature, rti.instanceType(instance));
+  }
+  return signature;
 }
 
-/// Returns the default type argument values for the instance method [name] on
-/// the class [type].
-JSArray<Object> getMethodDefaultTypeArgs(type, name) =>
-    JS('!', '#[#]', getMethodsDefaultTypeArgs(type), name);
+/// Returns the type of a method [name] from an object instance [obj].
+getMethodType(obj, name) {
+  var typeSigHolder = getTypeSignatureContainer(obj);
+  var m = getMethods(typeSigHolder);
+  if (m == null) return null;
+  return rtiFromSignature(obj, JS<Object?>('', '#[#]', m, name));
+}
 
-/// Gets the type of the corresponding setter (this includes writable fields).
-getSetterType(type, name) {
-  var setters = getSetters(type);
+/// Returns the default type argument values for the instance method [name].
+JSArray<Object> getMethodDefaultTypeArgs(obj, name) {
+  var typeSigHolder = getTypeSignatureContainer(obj);
+  var typeArgsOrFunction =
+      JS<Object>('', '#[#]', getMethodsDefaultTypeArgs(typeSigHolder), name);
+  if (JS<bool>('!', 'typeof # == "function"', typeArgsOrFunction)) {
+    // Signatures for generic types are resolved at runtime.
+    // A JS function here indicates that this signature has not yet been bound
+    // to an instance.
+    typeArgsOrFunction =
+        JS<Object>('', '#(#)', typeArgsOrFunction, rti.instanceType(obj));
+  }
+  return JS<JSArray<Object>>('', '#', typeArgsOrFunction);
+}
+
+/// Returns the type of a setter [name] from an object instance [obj].
+getSetterType(obj, name) {
+  var typeSigHolder = getTypeSignatureContainer(obj);
+  var setters = getSetters(typeSigHolder);
   if (setters != null) {
-    var type = JS('', '#[#]', setters, name);
     // TODO(nshahan): setters object has properties installed on the global
     // Object that requires some extra validation to ensure they are intended
     // as setters. ex: dartx.hashCode, dartx._equals, dartx.toString etc.
@@ -293,15 +231,20 @@
     // There is a value mapped to 'toString' in setters so broken code like this
     // results in very confusing behavior:
     // `d.toString = 99;`
-    if (type != null) {
-      return type;
+    var type = JS<Object?>('', '#[#]', setters, name);
+    if (type != null && JS<bool>('!', 'typeof # == "function"', type)) {
+      // Signatures for generic types are resolved at runtime.
+      // A JS function here indicates that this signature has not yet been bound
+      // to an instance.
+      type = JS<Object>('', '#(#)', type, rti.instanceType(obj));
     }
+    if (type != null) return type;
   }
-  var fields = getFields(type);
+  var fields = getFields(typeSigHolder);
   if (fields != null) {
-    var fieldInfo = JS('', '#[#]', fields, name);
+    var fieldInfo = JS<Object?>('', '#[#]', fields, name);
     if (fieldInfo != null && JS<bool>('!', '!#.isFinal', fieldInfo)) {
-      return JS('', '#.type', fieldInfo);
+      return rtiFromSignature(obj, JS<Object?>('', '#.type', fieldInfo));
     }
   }
   return null;
diff --git a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/debugger.dart b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/debugger.dart
index 9f5e909..bd3ca45 100644
--- a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/debugger.dart
+++ b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/debugger.dart
@@ -96,7 +96,8 @@
 /// ```
 /// TODO(annagrin): remove when debugger reads symbols.
 /// Issue: https://github.com/dart-lang/sdk/issues/40273
-Object? getClassMetadata(@notNull String libraryUri, @notNull String name) {
+Object? getClassMetadata(@notNull String libraryUri, @notNull String name,
+    {Object? objectInstance}) {
   var library = getLibrary('$libraryUri');
   if (library == null) throw 'cannot find library for $libraryUri';
 
@@ -108,6 +109,7 @@
   _collectFieldDescriptors(
     fieldDescriptors,
     getFields(cls),
+    objectInstance: objectInstance,
   );
   _collectFieldDescriptorsFromNames(
     fieldDescriptors,
@@ -222,17 +224,19 @@
   @notNull Map<String, dynamic> fieldDescriptors,
   Object? fields, {
   bool isStatic = false,
+  Object? objectInstance,
 }) {
   if (fields == null) return;
 
   for (var symbol in getOwnNamesAndSymbols(fields)) {
     var fieldInfo = _get<Object>(fields, symbol);
-    var type = _get(fieldInfo, 'type');
+    // An object instance is required to resolve the type of a field.
+    var typeSignature = _get(fieldInfo, 'type');
+    var typeRti = rtiFromSignature(objectInstance, typeSignature);
+    var className = typeRti == null ? '?' : typeName(typeRti);
     var isConst = _get(fieldInfo, 'isConst');
     var isFinal = _get(fieldInfo, 'isFinal');
     var libraryId = _get(fieldInfo, 'libraryUri');
-
-    var className = typeName(type);
     var name = _getDartSymbolName(symbol);
     if (name == null) continue;
 
diff --git a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/errors.dart b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/errors.dart
index 4242a6d..da32ef2 100644
--- a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/errors.dart
+++ b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/errors.dart
@@ -107,23 +107,6 @@
 }
 
 String _castErrorMessage(from, to) {
-  // If both types are generic classes, see if we can infer generic type
-  // arguments for `from` that would allow the subtype relation to work.
-  // TODO(#40326) Fix suggested type or remove this code if no longer needed.
-  // var fromClass = getGenericClass(from);
-  // if (fromClass != null) {
-  //   var fromTypeFormals = getGenericTypeFormals(fromClass);
-  //   var fromType = instantiateClass(fromClass, fromTypeFormals);
-  //   var inferrer = _TypeInferrer(fromTypeFormals);
-  //   if (inferrer.trySubtypeMatch(fromType, to)) {
-  //     var inferredTypes = inferrer.getInferredTypes();
-  //     if (inferredTypes != null) {
-  //       var inferred = instantiateClass(fromClass, inferredTypes);
-  //       return "Type '${typeName(from)}' should be '${typeName(inferred)}' "
-  //           "to implement expected type '${typeName(to)}'.";
-  //     }
-  //   }
-  // }
   var fromName = "'${typeName(from)}'";
   var toName = "'${typeName(to)}'";
   if (fromName == toName) {
diff --git a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/operations.dart b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/operations.dart
index 413d545..8b029c1 100644
--- a/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/operations.dart
+++ b/sdk/lib/_internal/js_dev_runtime/private/ddc_runtime/operations.dart
@@ -53,15 +53,14 @@
   // TODO(jmesserly): canonicalize tearoffs.
   JS('', '#._boundObject = #', f, obj);
   JS('', '#._boundMethod = #', f, method);
-  var objType = getType(obj);
-  var methodType = getMethodType(objType, name);
+  var methodType = getMethodType(obj, name);
   // Native JavaScript methods do not have Dart signatures attached that need
   // to be copied.
   if (methodType != null) {
     if (rti.isGenericFunctionType(methodType)) {
       // Attach the default type argument values to the new function in case
       // they are needed for a dynamic call.
-      var defaultTypeArgs = getMethodDefaultTypeArgs(objType, name);
+      var defaultTypeArgs = getMethodDefaultTypeArgs(obj, name);
       JS('', '#._defaultTypeArgs = #', f, defaultTypeArgs);
     }
     JS('', '#[#] = #', f, JS_GET_NAME(JsGetName.SIGNATURE_NAME), methodType);
@@ -80,8 +79,7 @@
 /// a native type/interface with `call`.
 bindCall(obj, name) {
   if (obj == null) return null;
-  var objType = getType(obj);
-  var ftype = getMethodType(objType, name);
+  var ftype = getMethodType(obj, name);
   if (ftype == null) return null;
   var method = JS('', '#[#]', obj, name);
   var f = JS('', '#.bind(#)', method, obj);
@@ -92,7 +90,7 @@
   if (rti.isGenericFunctionType(ftype)) {
     // Attach the default type argument values to the new function in case
     // they are needed for a dynamic call.
-    var defaultTypeArgs = getMethodDefaultTypeArgs(objType, name);
+    var defaultTypeArgs = getMethodDefaultTypeArgs(obj, name);
     JS('', '#._defaultTypeArgs = #', f, defaultTypeArgs);
   }
   return f;
@@ -104,8 +102,8 @@
 /// associated function type.
 gbind(f, @rest List<Object> typeArgs) {
   Object fnType = JS('!', '#[#]', f, JS_GET_NAME(JsGetName.SIGNATURE_NAME));
-  var instantiationBinding =
-      rti.bindingRtiFromList(JS<JSArray>('!', '#', typeArgs));
+  var typeArgsAsJSArray = JS<JSArray<Object>>('!', '#', typeArgs);
+  var instantiationBinding = rti.bindingRtiFromList(typeArgsAsJSArray);
   var instantiatedType = rti.instantiatedGenericFunctionType(
       JS<rti.Rti>('!', '#', fnType), instantiationBinding);
   // Create a JS wrapper function that will also pass the type arguments.
@@ -114,7 +112,7 @@
   // Tag the wrapper with the original function to be used for equality
   // checks.
   JS('', '#["_originalFn"] = #', result, f);
-  JS('', '#["_typeArgs"] = #', result, constList(typeArgs, Object));
+  JS('', '#["_typeArgs"] = #', result, constList<Object>(typeArgsAsJSArray));
 
   // Tag the wrapper with the instantiated function type.
   return fn(result, instantiatedType);
@@ -133,10 +131,11 @@
 
   trackCall(obj);
   if (f != null) {
-    var type = getType(obj);
+    var typeSigHolder = getTypeSignatureContainer(obj);
 
-    if (hasField(type, f) || hasGetter(type, f)) return JS('', '#[#]', obj, f);
-    if (hasMethod(type, f)) return bind(obj, f, null);
+    if (hasField(typeSigHolder, f) || hasGetter(typeSigHolder, f))
+      return JS('', '#[#]', obj, f);
+    if (hasMethod(typeSigHolder, f)) return bind(obj, f, null);
 
     // Handle record types by trying to access [f] via convenience getters.
     if (_jsInstanceOf(obj, RecordImpl) && f is String) {
@@ -152,19 +151,13 @@
   return noSuchMethod(obj, InvocationImpl(field, JS('', '[]'), isGetter: true));
 }
 
-_stripGenericArguments(type) {
-  var genericClass = getGenericClass(type);
-  if (genericClass != null) return JS('', '#()', genericClass);
-  return type;
-}
-
 dputRepl(obj, field, value) => dput(obj, replNameLookup(obj, field), value);
 
 dput(obj, field, value) {
   var f = _canonicalMember(obj, field);
   trackCall(obj);
   if (f != null) {
-    var setterType = getSetterType(getType(obj), f);
+    var setterType = getSetterType(obj, f);
     if (setterType != null) {
       return JS('', '#[#] = #.#(#)', obj, f, setterType,
           JS_GET_NAME(JsGetName.RTI_FIELD_AS), value);
@@ -504,11 +497,10 @@
     return noSuchMethod(obj, InvocationImpl(displayName, args, isMethod: true));
   }
   var f = obj != null ? JS('', '#[#]', obj, symbol) : null;
-  var type = getType(obj);
-  var ftype = getMethodType(type, symbol);
+  var ftype = getMethodType(obj, symbol);
   if (ftype != null && rti.isGenericFunctionType(ftype) && typeArgs == null) {
     // No type arguments were provided, use the default values in this call.
-    typeArgs = getMethodDefaultTypeArgs(type, symbol);
+    typeArgs = getMethodDefaultTypeArgs(obj, symbol);
   }
   // No such method if dart object and ftype is missing.
   return _checkAndCall(f, ftype, obj, typeArgs, args, named, displayName);
@@ -607,9 +599,6 @@
   return x;
 }
 
-/// The global constant map table.
-final constantMaps = JS<Object>('!', 'new Map()');
-
 // TODO(leafp): This table gets quite large in apps.
 // Keeping the paths is probably expensive.  It would probably
 // be more space efficient to just use a direct hash table with
@@ -621,6 +610,30 @@
   return result!;
 }
 
+/// The global constant list table.
+/// This maps the number of elements in the list (n)
+/// to a path of length n of maps indexed by the value
+/// of the field.  The final map is indexed by the element
+/// type and contains the canonical version of the list.
+final constantLists = JS<Object>('!', 'new Map()');
+
+/// Canonicalize a constant list
+List<E> constList<E>(JSArray elements) {
+  var count = elements.length;
+  var map = _lookupNonTerminal(constantLists, count);
+  for (var i = 0; i <= count; i++) {
+    map = _lookupNonTerminal(map, JS('', '#[#]', elements, i));
+  }
+  List<E>? result = JS('', '#.get(#)', map, E);
+  if (result != null) return result;
+  result = JSArray.unmodifiable(elements);
+  JS('', '#.set(#, #)', map, E, result);
+  return result;
+}
+
+/// The global constant map table.
+final constantMaps = JS<Object>('!', 'new Map()');
+
 Map<K, V> constMap<K, V>(JSArray elements) {
   var count = elements.length;
   var map = _lookupNonTerminal(constantMaps, count);
@@ -728,28 +741,6 @@
   return $obj;
 })()''');
 
-/// The global constant list table.
-/// This maps the number of elements in the list (n)
-/// to a path of length n of maps indexed by the value
-/// of the field.  The final map is indexed by the element
-/// type and contains the canonical version of the list.
-final constantLists = JS('', 'new Map()');
-
-/// Canonicalize a constant list
-constList(elements, elementType) => JS('', '''(() => {
-  let count = $elements.length;
-  let map = $_lookupNonTerminal($constantLists, count);
-  for (let i = 0; i < count; i++) {
-    map = $_lookupNonTerminal(map, elements[i]);
-  }
-  let value = map.get($elementType);
-  if (value) return value;
-
-  ${getGenericClassStatic<JSArray>()}($elementType).unmodifiable($elements);
-  map.set($elementType, elements);
-  return elements;
-})()''');
-
 constFn(x) => JS('', '() => x');
 
 /// Gets the extension symbol given a member [name].
diff --git a/sdk/lib/_internal/js_dev_runtime/private/debugger.dart b/sdk/lib/_internal/js_dev_runtime/private/debugger.dart
index ab67707..8840907 100644
--- a/sdk/lib/_internal/js_dev_runtime/private/debugger.dart
+++ b/sdk/lib/_internal/js_dev_runtime/private/debugger.dart
@@ -568,13 +568,15 @@
   bool hasChildren(object) => true;
 
   children(object) {
-    var type = dart.getType(object);
+    var typeSigHolder = dart.getTypeSignatureContainer(object);
     var ret = LinkedHashSet<NameValuePair>();
     // We use a Set rather than a List to avoid duplicates.
     var fields = Set<NameValuePair>();
-    addPropertiesFromSignature(dart.getFields(type), fields, object, true);
+    addPropertiesFromSignature(
+        dart.getFields(typeSigHolder), fields, object, true);
     var getters = Set<NameValuePair>();
-    addPropertiesFromSignature(dart.getGetters(type), getters, object, true);
+    addPropertiesFromSignature(
+        dart.getGetters(typeSigHolder), getters, object, true);
     ret.addAll(sortProperties(fields));
     ret.addAll(sortProperties(getters));
     addMetadataChildren(object, ret);
diff --git a/sdk/lib/_internal/js_dev_runtime/private/foreign_helper.dart b/sdk/lib/_internal/js_dev_runtime/private/foreign_helper.dart
index 0d0ffb4..65275b5 100644
--- a/sdk/lib/_internal/js_dev_runtime/private/foreign_helper.dart
+++ b/sdk/lib/_internal/js_dev_runtime/private/foreign_helper.dart
@@ -209,6 +209,10 @@
 /// representations in JavaScript.
 external String JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG();
 
+/// Returns the identifier associated with the RTI parameter passed to some
+/// generic constructors, factories, and signatures.
+external String JS_RTI_PARAMETER();
+
 /// Returns the JS name for [name] from the Namer.
 @pragma('ddc:trust-inline')
 external String JS_GET_NAME(JsGetName name);
diff --git a/sdk/lib/_internal/js_dev_runtime/private/interceptors.dart b/sdk/lib/_internal/js_dev_runtime/private/interceptors.dart
index 22d6926..42848d3 100644
--- a/sdk/lib/_internal/js_dev_runtime/private/interceptors.dart
+++ b/sdk/lib/_internal/js_dev_runtime/private/interceptors.dart
@@ -7,7 +7,7 @@
 import 'dart:collection';
 import 'dart:_internal' hide Symbol;
 import 'dart:_js_helper';
-import 'dart:_foreign_helper' show JS, JS_GET_FLAG, TYPE_REF;
+import 'dart:_foreign_helper' show JS, JS_GET_FLAG, TYPE_REF, JS_RTI_PARAMETER;
 import 'dart:math' show Random, ln2;
 import 'dart:_rti' as rti show createRuntimeType, Rti;
 import 'dart:_runtime' as dart;
diff --git a/sdk/lib/_internal/js_dev_runtime/private/js_array.dart b/sdk/lib/_internal/js_dev_runtime/private/js_array.dart
index af4742c..553f0cb 100644
--- a/sdk/lib/_internal/js_dev_runtime/private/js_array.dart
+++ b/sdk/lib/_internal/js_dev_runtime/private/js_array.dart
@@ -4,6 +4,9 @@
 
 part of dart._interceptors;
 
+/// Holds cached RTI objects for JS Array instances.
+final _arrayRtiSymbol = JS<Object>('', 'Symbol("arrayRti")');
+
 /// The interceptor class for [List]. The compiler recognizes this
 /// class as an interceptor, and changes references to [:this:] to
 /// actually use the receiver of the method, which is generated as an extra
@@ -17,34 +20,36 @@
   /// Array. Used for creating literal lists.
   factory JSArray.of(@notNull Object list) {
     // TODO(sra): Move this to core.List for better readability.
-    //
-    // TODO(jmesserly): this uses special compiler magic to close over the
-    // parameterized ES6 'JSArray' class.
-    jsObjectSetPrototypeOf(list, JS('', 'JSArray.prototype'));
+    jsObjectSetPrototypeOf(list, JS('', 'this.prototype'));
+    JS('', '#.# = #', list, _arrayRtiSymbol, JS_RTI_PARAMETER());
     return JS('-dynamic', '#', list);
   }
 
   // TODO(jmesserly): consider a fixed array subclass instead.
   factory JSArray.fixed(@notNull Object list) {
-    jsObjectSetPrototypeOf(list, JS('', 'JSArray.prototype'));
+    jsObjectSetPrototypeOf(list, JS('', 'this.prototype'));
     JS('', r'#.fixed$length = Array', list);
+    JS('', '#.# = #', list, _arrayRtiSymbol, JS_RTI_PARAMETER());
     return JS('-dynamic', '#', list);
   }
 
   factory JSArray.unmodifiable(@notNull Object list) {
-    jsObjectSetPrototypeOf(list, JS('', 'JSArray.prototype'));
+    jsObjectSetPrototypeOf(list, JS('', 'this.prototype'));
     JS('', r'#.fixed$length = Array', list);
     JS('', r'#.immutable$list = Array', list);
+    JS('', '#.# = #', list, _arrayRtiSymbol, JS_RTI_PARAMETER());
     return JS('-dynamic', '#', list);
   }
 
   /// Provides the Rti object for this.
   ///
+  /// Default-initialized to JSArray<dynamic>.
   /// Only intended for use by the dart:_rti library.
   ///
   /// NOTE: The name of this getter is directly tied to the result of compiling
   /// `JS_EMBEDDED_GLOBAL('', ARRAY_RTI_PROPERTY)`.
-  Object get arrayRti => TYPE_REF<JSArray<E>>();
+  Object get arrayRti => JS<Object>(
+      '', '#.# || #', this, _arrayRtiSymbol, TYPE_REF<JSArray<dynamic>>());
 
   /// Unsupported action, only provided here to help diagnosis of an accidental
   /// attempt to set the value manually.
diff --git a/tests/dartdevc/const_test.dart b/tests/dartdevc/const_test.dart
index 24f46ab..f40a5c1 100644
--- a/tests/dartdevc/const_test.dart
+++ b/tests/dartdevc/const_test.dart
@@ -10,7 +10,7 @@
   dynamic data = JS('', '[1, 2, 3, 4]');
   Expect.isFalse(data is List<int>);
 
-  var list = dart.constList(data, TYPE_REF<int>());
+  var list = dart.constList<int>(data);
   Expect.isTrue(list is List<int>);
   Expect.throws(() {
     list[0] = 0;
diff --git a/tests/dartdevc/debugger/debugger_test_golden.txt b/tests/dartdevc/debugger/debugger_test_golden.txt
index 78231d9..59970a2 100644
--- a/tests/dartdevc/debugger/debugger_test_golden.txt
+++ b/tests/dartdevc/debugger/debugger_test_golden.txt
@@ -239,7 +239,7 @@
     {
         "style": "background-color: #d9edf7;color: black"
     },
-    "List<Object>"
+    "List"
 ]
 -----------------------------------
 Test: List<Object> definition formatting body
@@ -1788,7 +1788,7 @@
     {
         "style": "background-color: #d9edf7;color: black"
     },
-    "List<int>"
+    "List"
 ]
 -----------------------------------
 Test: List<int> large definition formatting body
@@ -3371,7 +3371,7 @@
     {
         "style": "background-color: #d9edf7;color: black"
     },
-    "MappedListIterable<String, String>"
+    "MappedListIterable"
 ]
 -----------------------------------
 Test: Iterable definition formatting body
@@ -4148,7 +4148,7 @@
     {
         "style": "background-color: #d9edf7;color: black"
     },
-    "LinkedSet<dynamic>"
+    "LinkedSet"
 ]
 -----------------------------------
 Test: Set definition formatting body
@@ -4560,7 +4560,7 @@
     {
         "style": "background-color: #d9edf7;color: black"
     },
-    "LinkedMap<dynamic, dynamic>"
+    "LinkedMap"
 ]
 -----------------------------------
 Test: Map<dynamic, dynamic> definition formatting body
@@ -5227,7 +5227,7 @@
             {
                 "style": "background-color: thistle; color: rgb(136, 19, 145); margin-right: -13px"
             },
-            "TestGenericClass<dynamic, dynamic>: "
+            "TestGenericClass: "
         ],
         [
             "span",
@@ -7063,7 +7063,7 @@
     {
         "style": "background-color: #d9edf7;color: black"
     },
-    "TestGenericClass<int, List<dynamic>>"
+    "TestGenericClass"
 ]
 -----------------------------------
 Test: TestGenericClass definition formatting body
@@ -7203,7 +7203,7 @@
     {
         "style": "background-color: #d9edf7;color: black"
     },
-    "Instance of 'TestGenericClass<ExampleJSClass<any>, int>'"
+    "Instance of 'TestGenericClass<ExampleJSClass<String>, int>'"
 ]
 -----------------------------------
 Test: TestGenericClassJSInterop instance body
@@ -7300,7 +7300,7 @@
     {
         "style": "background-color: #d9edf7;color: black"
     },
-    "TestGenericClass<ExampleJSClass<any>, int>"
+    "TestGenericClass"
 ]
 -----------------------------------
 Test: TestGenericClassJSInterop definition formatting body
diff --git a/tests/dartdevc/js_interop_non_external_lib.dart b/tests/dartdevc/js_interop_non_external_lib.dart
index ef6eaa9..4066b98 100644
--- a/tests/dartdevc/js_interop_non_external_lib.dart
+++ b/tests/dartdevc/js_interop_non_external_lib.dart
@@ -12,6 +12,12 @@
 import 'package:expect/expect.dart';
 import 'package:js/js.dart';
 
+late List topLevelList;
+
+void topLevelListAppend(item) {
+  topLevelList.add(item);
+}
+
 @JS('JSClass')
 class OtherJSClass<T extends num> {
   external OtherJSClass.cons(T t);
@@ -20,6 +26,7 @@
     Expect.type<T>(t);
     Expect.notType<T>('');
     field = 'unnamed';
+    topLevelList = <T>[t];
     return OtherJSClass.cons(t);
   }
 
@@ -28,6 +35,7 @@
     Expect.type<T>(t);
     Expect.notType<T>('');
     field = 'named';
+    topLevelList = <T>[t];
     return OtherJSClass.cons(t);
   }
 
diff --git a/tests/dartdevc/js_interop_non_external_test.dart b/tests/dartdevc/js_interop_non_external_test.dart
index 25cf658..e827810 100644
--- a/tests/dartdevc/js_interop_non_external_test.dart
+++ b/tests/dartdevc/js_interop_non_external_test.dart
@@ -13,6 +13,8 @@
 
 import 'js_interop_non_external_lib.dart';
 
+class _Class {}
+
 @JS()
 external dynamic eval(String code);
 
@@ -138,8 +140,12 @@
   expect(OtherJSClass.field, 'modified');
 
   OtherJSClass<int>(0);
+  Expect.throws<TypeError>(() => topLevelListAppend(_Class()));
+  topLevelListAppend(42);
   expect(OtherJSClass.field, 'unnamed');
   OtherJSClass.named(0);
+  Expect.throws<TypeError>(() => topLevelListAppend(_Class()));
+  topLevelListAppend(42);
   expect(OtherJSClass.field, 'named');
   OtherJSClass<double>.redirecting(0.1);
   expect(OtherJSClass.field, 'unnamed');
diff --git a/tests/language/factory/factory_const_test.dart b/tests/language/factory/factory_const_test.dart
new file mode 100644
index 0000000..5bf403e
--- /dev/null
+++ b/tests/language/factory/factory_const_test.dart
@@ -0,0 +1,26 @@
+// Copyright (c) 2024, 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.
+
+// Tests that generic constants can be constructed from a named factory.
+
+import "package:expect/expect.dart";
+
+class Optional<T> {
+  final T? value;
+  const Optional.absent() : value = null;
+}
+
+class Foo {
+  Optional<int> value;
+  Foo._(this.value);
+  factory Foo.named() {
+    return Foo._(const Optional.absent());
+  }
+}
+
+void main() {
+  var foo = Foo.named();
+  Expect.equals(foo.value, const Optional<int>.absent());
+  Expect.equals(foo.value.value, null);
+}
diff --git a/tests/language/generic_methods/generic_static_tearoffs_test.dart b/tests/language/generic_methods/generic_static_tearoffs_test.dart
new file mode 100644
index 0000000..c120dff
--- /dev/null
+++ b/tests/language/generic_methods/generic_static_tearoffs_test.dart
@@ -0,0 +1,43 @@
+// Copyright (c) 2024, 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.
+
+import "package:expect/expect.dart";
+
+class Foo<T> {
+  static final create = <U>(e) => C<U>.filled(e);
+}
+
+class C<T> implements I<T>, J<T> {
+  final T value;
+
+  C(this.value);
+
+  factory C.filled(T fill) {
+    return C<T>(fill);
+  }
+}
+
+abstract mixin class I<E> {
+  I();
+}
+
+mixin class J<E> {
+  J();
+}
+
+void main() {
+  var foo1 = Foo.create<int>(42);
+  Expect.equals(foo1.value, 42);
+  Expect.type<C<int>>(foo1);
+
+  var j = J<J<bool>>();
+
+  var foo2 = Foo.create(j);
+  Expect.equals(foo2.value, j);
+  Expect.type<C<dynamic>>(foo2);
+
+  var foo3 = Foo.create<J<J<bool>>>(j);
+  Expect.equals(foo3.value, j);
+  Expect.type<C<J<J<bool>>>>(foo3);
+}
diff --git a/tests/language/mixin/covariant_mixin_stub_test.dart b/tests/language/mixin/covariant_mixin_stub_test.dart
new file mode 100644
index 0000000..36e08e2
--- /dev/null
+++ b/tests/language/mixin/covariant_mixin_stub_test.dart
@@ -0,0 +1,54 @@
+// Copyright (c) 2024, 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.
+
+// Tests that implicit covariant type checks in super calls from generic mixin
+// forwarding stubs behave properly when type parameters are shuffled.
+
+import "package:expect/expect.dart";
+
+abstract class ClassWithGenericMix<TypeArgA1, TypeArgA2, TypeArgA3>
+    extends ClassWithCovariantSuperCall
+    with GenericMixWithCovariantOverride<TypeArgA1, TypeArgA3, TypeArgA2> {
+  const ClassWithGenericMix({super.key});
+}
+
+mixin Mix<TypeArgB1, TypeArgB2, TypeArgB3> on Object {}
+
+class ClassWithCovariantSuperCall extends ConstWrapper {
+  const ClassWithCovariantSuperCall({super.key});
+
+  void update(covariant Object obj) {
+    print('updated!');
+  }
+}
+
+mixin GenericMixWithCovariantOverride<TypeArgC1, TypeArgC2, TypeArgC3>
+    on ClassWithCovariantSuperCall {
+  @override
+  void update(Mix<TypeArgC3, TypeArgC1, TypeArgC2> obj);
+}
+
+class ConstWrapper {
+  final dynamic key;
+  const ConstWrapper({this.key});
+}
+
+class ClassWithGenericMixImpl extends ClassWithGenericMix<int, String, bool> {
+  final ConstWrapper element;
+
+  const ClassWithGenericMixImpl({
+    required this.element,
+  });
+}
+
+class ClassWithMix extends Object with Mix<String, int, bool> {}
+
+void main() {
+  var wrapper = const ConstWrapper();
+  var impl = ClassWithGenericMixImpl(element: wrapper);
+  var mixedIn = ClassWithMix();
+  impl.update(mixedIn);
+
+  Expect.equals(impl.element, wrapper);
+}