diff --git a/pkg/dev_compiler/lib/src/compiler/js_names.dart b/pkg/dev_compiler/lib/src/compiler/js_names.dart
index 3c48dc8..97921d9 100644
--- a/pkg/dev_compiler/lib/src/compiler/js_names.dart
+++ b/pkg/dev_compiler/lib/src/compiler/js_names.dart
@@ -19,10 +19,6 @@
   static const operatorIsPrefix = r'$is_';
   static const operatorSignature = r'$signature';
   static const rtiName = r'$ti';
-  // TODO(48585) Fix this name.
-  static const futureClassName = 'TODO';
-  // TODO(48585) Fix this name.
-  static const listClassName = 'TODO';
   static const rtiAsField = '_as';
   static const rtiIsField = '_is';
 }
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index b9a3646..7827185 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -41,6 +41,7 @@
 import 'nullable_inference.dart';
 import 'property_model.dart';
 import 'target.dart' show allowedNativeTest;
+import 'type_environment.dart';
 import 'type_recipe_generator.dart';
 import 'type_table.dart';
 
@@ -131,6 +132,12 @@
   /// True when a class is emitting a deferred class hierarchy.
   bool _emittingDeferredType = false;
 
+  /// The current type environment of type parameters introduced to the scope
+  /// via generic classes and functions.
+  DDCTypeEnvironment _currentTypeEnvironment = const EmptyTypeEnvironment();
+
+  final TypeRecipeGenerator _typeRecipeGenerator;
+
   /// The current element being loaded.
   /// We can use this to determine if we're loading top-level code or not:
   ///
@@ -188,6 +195,9 @@
 
   final _superHelpers = <String, js_ast.Method>{};
 
+  /// Cache for the results of calling [_typeParametersInHierarchy].
+  final _typeParametersInHierarchyCache = <Class, bool>{};
+
   // Compilation of Kernel's [BreakStatement].
   //
   // Kernel represents Dart's `break` and `continue` uniformly as
@@ -345,7 +355,8 @@
         _asyncStarImplClass = sdk.getClass('dart:async', '_AsyncStarImpl'),
         _assertInteropMethod = sdk.getTopLevelMember(
             'dart:_runtime', 'assertInterop') as Procedure,
-        _futureOrNormalizer = FutureOrNormalizer(_coreTypes);
+        _futureOrNormalizer = FutureOrNormalizer(_coreTypes),
+        _typeRecipeGenerator = TypeRecipeGenerator(_coreTypes);
 
   @override
   Library? get currentLibrary => _currentLibrary;
@@ -682,6 +693,12 @@
     _currentClass = c;
     _currentLibrary = c.enclosingLibrary;
     _currentUri = c.fileUri;
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    // When compiling the type heritage of the class we can't reference an rti
+    // object attached to an instance. Instead we construct a type environment
+    // manually when needed. Later we use the rti attached to an instance for
+    // a simpler representation within instance members of the class.
+    _currentTypeEnvironment = _currentTypeEnvironment.extend(c.typeParameters);
 
     // Mixins are unrolled in _defineClass.
     // If this class is annotated with `@JS`, then there is nothing to emit.
@@ -697,6 +714,7 @@
     _currentClass = savedClass;
     _currentLibrary = savedLibrary;
     _currentUri = savedUri;
+    _currentTypeEnvironment = savedTypeEnvironment;
   }
 
   /// To emit top-level classes, we sometimes need to reorder them.
@@ -759,7 +777,15 @@
     });
 
     var jsCtors = _defineConstructors(c, className);
+    // Emitting class members in a class type environment results in a more
+    // succinct type representation when referencing class type arguments from
+    // instance members.
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    if (c.typeParameters.isNotEmpty) {
+      _currentTypeEnvironment = ClassTypeEnvironment(c.typeParameters);
+    }
     var jsMethods = _emitClassMethods(c);
+    _currentTypeEnvironment = savedTypeEnvironment;
 
     _emitSuperHelperSymbols(body);
     // Deferred supertypes must be evaluated lazily while emitting classes to
@@ -785,7 +811,7 @@
 
     // Attach caches on all canonicalized types.
     if (_options.newRuntimeTypes) {
-      var name = TypeRecipeGenerator.interfaceTypeRecipe(c);
+      var name = _typeRecipeGenerator.interfaceTypeRecipe(c);
       body.add(runtimeStatement(
           'addRtiResources(#, #)', [className, js.string(name)]));
     }
@@ -1687,6 +1713,18 @@
     // multiple constructors, but it needs to be balanced against readability.
     body.add(_initializeFields(fields, node));
 
+    // Instances of classes with type arguments need an rti object attached to
+    // them since the type arguments could be instantiated differently for
+    // each instance.
+    if (_options.newRuntimeTypes && _typeParametersInHierarchy(cls)) {
+      var type = cls.getThisType(_coreTypes, Nullability.nonNullable);
+      // Only set the rti if there isn't one already. This avoids superclasses
+      // from overwriting the value already set by subclass.
+      var rtiProperty = propertyName(js_ast.FixedNames.rtiName);
+      body.add(js.statement(
+          'this.# = this.# || #', [rtiProperty, rtiProperty, _emitType(type)]));
+    }
+
     // If no superinitializer is provided, an implicit superinitializer of the
     // form `super()` is added at the end of the initializer list, unless the
     // enclosing class is class Object.
@@ -1700,6 +1738,19 @@
     return body;
   }
 
+  /// Returns `true` if [cls] or any of its transitive super classes has
+  /// generic type parameters.
+  bool _typeParametersInHierarchy(Class? cls) {
+    if (cls == null) return false;
+    var cachedResult = _typeParametersInHierarchyCache[cls];
+    if (cachedResult != null) return cachedResult;
+    var hasTypeParameters = cls.typeParameters.isNotEmpty
+        ? true
+        : _typeParametersInHierarchy(cls.superclass);
+    _typeParametersInHierarchyCache[cls] = hasTypeParameters;
+    return hasTypeParameters;
+  }
+
   js_ast.LiteralString _constructorName(String name) {
     if (name == '') {
       // Default constructors (factory or not) use `new` as their name.
@@ -2182,12 +2233,16 @@
     /// own type parameters, this will need to be changed to call
     /// [_emitFunction] instead.
     var name = node.name.text;
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    _currentTypeEnvironment =
+        _currentTypeEnvironment.extend(function.typeParameters);
     var jsBody = _emitSyncFunctionBody(function, name);
     var jsName = _constructorName(name);
     memberNames[node] = jsName.valueWithoutQuotes;
+    var jsParams = _emitParameters(function);
+    _currentTypeEnvironment = savedTypeEnvironment;
 
-    return js_ast.Method(jsName, js_ast.Fun(_emitParameters(function), jsBody),
-        isStatic: true)
+    return js_ast.Method(jsName, js_ast.Fun(jsParams, jsBody), isStatic: true)
       ..sourceInformation = _nodeEnd(node.fileEndOffset);
   }
 
@@ -2945,10 +3000,79 @@
   /// Returns an expression that evaluates to the rti object from the dart:_rti
   /// library that represents [type].
   js_ast.Expression _newEmitType(DartType type) {
+    /// Returns an expression that evaluates a type [recipe] within the type
+    /// [environment].
+    ///
+    /// At runtime the expression will evaluate to an rti object.
+    js_ast.Expression emitRtiEval(
+            js_ast.Expression environment, String recipe) =>
+        js.call('#.#("$recipe")',
+            [environment, _emitMemberName('_eval', memberClass: rtiClass)]);
+
+    /// Returns an expression that binds a type [parameter] within the type
+    /// [environment].
+    ///
+    /// At runtime the expression will evaluate to an rti object that has been
+    /// extended to include the provided [parameter].
+    js_ast.Expression emitRtiBind(
+            js_ast.Expression environment, TypeParameter parameter) =>
+        js.call('#.#(#)', [
+          environment,
+          _emitMemberName('_bind', memberClass: rtiClass),
+          _emitTypeParameter(parameter)
+        ]);
+
+    /// Returns an expression that evaluates a type [recipe] in a type
+    /// [environment] resulting in an rti object.
+    js_ast.Expression evalInEnvironment(
+        DDCTypeEnvironment environment, String recipe) {
+      if (environment is EmptyTypeEnvironment) {
+        return js.call('#.findType("$recipe")', [emitLibraryName(rtiLibrary)]);
+      } else if (environment is BindingTypeEnvironment) {
+        js_ast.Expression env;
+        if (environment.isSingleTypeParameter) {
+          // An environment with a single type parameter can be simplified to
+          // just that parameter.
+          env = _emitTypeParameter(environment.parameters.single);
+        } else {
+          var environmentTypes = environment.parameters;
+          // Create a dummy interface type to "hold" type arguments.
+          env = emitRtiEval(_emitTypeParameter(environmentTypes.first), '@<0>');
+          // Bind remaining type arguments.
+          for (var i = 1; i < environmentTypes.length; i++) {
+            env = emitRtiBind(env, environmentTypes[i]);
+          }
+        }
+        return emitRtiEval(env, recipe);
+      } else if (environment is ClassTypeEnvironment) {
+        // Class type environments are already constructed and attached to the
+        // instance of a generic class.
+        return js.call('this.${js_ast.FixedNames.rtiName}');
+      } else if (environment is ExtendedClassTypeEnvironment) {
+        // A generic class instance already stores a reference to a type
+        // containing all of its type arguments.
+        var env = js.call('this.${js_ast.FixedNames.rtiName}');
+        // Bind extra type parameters.
+        for (var parameter in environment.extendedParameters) {
+          env = emitRtiBind(env, parameter);
+        }
+        return emitRtiEval(env, recipe);
+      } else {
+        _typeCompilationError(type,
+            'Unexpected DDCTypeEnvironment type (${environment.runtimeType}).');
+      }
+    }
+
+    // TODO(nshahan) Avoid calling _emitType when we actually want a
+    // reference to an rti that already exists in scope.
+    if (type is TypeParameterType && type.isPotentiallyNonNullable) {
+      return _emitTypeParameterType(type, emitNullability: false);
+    }
     var normalizedType = _futureOrNormalizer.normalize(type);
     try {
-      var recipe = normalizedType.accept(TypeRecipeGenerator());
-      return js.call('#.findType("$recipe")', [emitLibraryName(rtiLibrary)]);
+      var result = _typeRecipeGenerator.recipeInEnvironment(
+          normalizedType, _currentTypeEnvironment);
+      return evalInEnvironment(result.requiredEnvironment, result.recipe);
     } on UnsupportedError catch (e) {
       _typeCompilationError(normalizedType, e.message ?? 'Unknown Error');
     }
@@ -3443,6 +3567,8 @@
   }
 
   js_ast.Fun _emitFunction(FunctionNode f, String? name) {
+    var savedTypeEnvironment = _currentTypeEnvironment;
+    _currentTypeEnvironment = _currentTypeEnvironment.extend(f.typeParameters);
     // normal function (sync), vs (sync*, async, async*)
     var isSync = f.asyncMarker == AsyncMarker.Sync;
     var formals = _emitParameters(f);
@@ -3462,6 +3588,7 @@
         : _emitGeneratorFunctionBody(f, name);
 
     block = super.exitFunction(formals, block);
+    _currentTypeEnvironment = savedTypeEnvironment;
     return js_ast.Fun(formals, block);
   }
 
@@ -5965,9 +6092,11 @@
       case JsGetName.RTI_NAME:
         return js.string(js_ast.FixedNames.rtiName);
       case JsGetName.FUTURE_CLASS_TYPE_NAME:
-        return js.string(js_ast.FixedNames.futureClassName);
+        return js.string(
+            _typeRecipeGenerator.interfaceTypeRecipe(_coreTypes.futureClass));
       case JsGetName.LIST_CLASS_TYPE_NAME:
-        return js.string(js_ast.FixedNames.listClassName);
+        return js.string(
+            _typeRecipeGenerator.interfaceTypeRecipe(_coreTypes.listClass));
       case JsGetName.RTI_FIELD_AS:
         return _emitMemberName(js_ast.FixedNames.rtiAsField,
             memberClass: rtiClass);
@@ -6907,12 +7036,16 @@
       return js_ast.Property(symbol, constant);
     }
 
-    var type = _emitInterfaceType(
-        node.getType(_staticTypeContext) as InterfaceType,
-        emitNullability: false);
-    var prototype = js.call('#.prototype', [type]);
+    var type = node.getType(_staticTypeContext);
+    var classRef =
+        _emitInterfaceType(type as InterfaceType, emitNullability: false);
+    var prototype = js.call('#.prototype', [classRef]);
     var properties = [
       js_ast.Property(propertyName('__proto__'), prototype),
+      if (_options.newRuntimeTypes && type.typeArguments.isNotEmpty)
+        // Generic interface type instances require a type information tag.
+        js_ast.Property(
+            propertyName(js_ast.FixedNames.rtiName), _emitType(type)),
       for (var e in node.fieldValues.entries.toList().reversed)
         entryToProperty(e),
     ];
diff --git a/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart b/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart
index 76a4b61..a97f328 100644
--- a/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart
+++ b/pkg/dev_compiler/lib/src/kernel/kernel_helpers.dart
@@ -371,3 +371,12 @@
 
 bool _isDartInternal(Uri uri) =>
     uri.isScheme('dart') && uri.path == '_internal';
+
+/// Collects all `TypeParameter`s from the `TypeParameterType`s present in the
+/// visited `DartType`.
+class TypeParameterTypeFinder extends RecursiveVisitor<void> {
+  final found = <TypeParameter>{};
+  @override
+  void visitTypeParameterType(TypeParameterType node) =>
+      found.add(node.parameter);
+}
diff --git a/pkg/dev_compiler/lib/src/kernel/type_environment.dart b/pkg/dev_compiler/lib/src/kernel/type_environment.dart
new file mode 100644
index 0000000..c8d5fd5
--- /dev/null
+++ b/pkg/dev_compiler/lib/src/kernel/type_environment.dart
@@ -0,0 +1,178 @@
+// Copyright (c) 2022, 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 'dart:collection';
+
+import 'package:kernel/ast.dart';
+
+/// Type environments made of type parameters.
+///
+/// At runtime, type recipes are evaluated in an environment to produce an rti.
+/// These compile time representations are used to calculate the indices of type
+/// parameters in type recipes.
+abstract class DDCTypeEnvironment {
+  /// Creates a new environment by adding [parameters] to those already in this
+  /// environment.
+  DDCTypeEnvironment extend(List<TypeParameter> parameters);
+
+  /// Reduces this environment down to an environment that will contain
+  /// [requiredTypes] and be output in a compact representation.
+  DDCTypeEnvironment prune(Iterable<TypeParameter> requiredParameters);
+
+  /// 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);
+}
+
+/// An empty environment that signals no type parameters are present or needed.
+///
+/// Facilitates building other environments.
+class EmptyTypeEnvironment implements DDCTypeEnvironment {
+  const EmptyTypeEnvironment();
+
+  @override
+  DDCTypeEnvironment extend(List<TypeParameter> parameters) =>
+      parameters.isEmpty ? this : BindingTypeEnvironment(parameters);
+
+  @override
+  DDCTypeEnvironment prune(Iterable<TypeParameter> requiredParameters) => this;
+
+  @override
+  int recipeIndexOf(TypeParameter parameter) => -1;
+}
+
+/// A type environment introduced by a class with one or more generic type
+/// parameters.
+class ClassTypeEnvironment implements DDCTypeEnvironment {
+  final List<TypeParameter> _typeParameters;
+  ClassTypeEnvironment(this._typeParameters);
+
+  @override
+  DDCTypeEnvironment extend(List<TypeParameter> parameters) =>
+      parameters.isEmpty
+          ? this
+          : ExtendedClassTypeEnvironment(this, [...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.
+      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;
+  }
+}
+
+/// A type environment containing multiple type parameters.
+class BindingTypeEnvironment implements DDCTypeEnvironment {
+  final List<TypeParameter> _typeParameters;
+
+  BindingTypeEnvironment(this._typeParameters);
+
+  @override
+  DDCTypeEnvironment extend(List<TypeParameter> parameters) =>
+      parameters.isEmpty
+          ? this
+          : BindingTypeEnvironment([
+              // Place new parameters first so they can effectively shadow
+              // parameters already in the environment.
+              ...parameters, ..._typeParameters
+            ]);
+
+  @override
+  DDCTypeEnvironment prune(Iterable<TypeParameter> requiredParameters) {
+    var foundParameters = requiredParameters.where(_typeParameters.contains);
+    if (foundParameters.isEmpty) return const EmptyTypeEnvironment();
+    if (foundParameters.length == _typeParameters.length) return this;
+    return BindingTypeEnvironment(foundParameters.toList());
+  }
+
+  @override
+  int recipeIndexOf(TypeParameter parameter) {
+    var i = _typeParameters.indexOf(parameter);
+    if (i < 0) return i;
+    // Environments containing a single parameter can have a more compact
+    // representation with a zero based index.
+    if (isSingleTypeParameter) return i;
+    return i + 1;
+  }
+
+  /// The type parameters in this environment.
+  List<TypeParameter> get parameters => UnmodifiableListView(_typeParameters);
+
+  /// Returns `true` if this environment only contains a single type parameter.
+  bool get isSingleTypeParameter => _typeParameters.length == 1;
+}
+
+/// A type environment based on one introduced by a generic class but extended
+/// with additional parameters from methods with generic type parameters.
+class ExtendedClassTypeEnvironment implements DDCTypeEnvironment {
+  final ClassTypeEnvironment _classEnvironment;
+  final List<TypeParameter> _typeParameters;
+
+  ExtendedClassTypeEnvironment(this._classEnvironment, this._typeParameters);
+
+  @override
+  DDCTypeEnvironment extend(List<TypeParameter> parameters) =>
+      parameters.isEmpty
+          ? this
+          : ExtendedClassTypeEnvironment(_classEnvironment, [
+              // Place new parameters first so they can effectively shadow
+              // parameters already in the environment.
+              ...parameters, ..._typeParameters
+            ]);
+
+  @override
+  DDCTypeEnvironment prune(Iterable<TypeParameter> requiredParameters) {
+    var classEnvironmentNeeded =
+        requiredParameters.any(_classEnvironment._typeParameters.contains);
+    var additionalParameters =
+        requiredParameters.where(_typeParameters.contains);
+    if (additionalParameters.isEmpty) {
+      return classEnvironmentNeeded
+          // Simply using the class environment has a compact representation
+          // and is already constructed.
+          ? _classEnvironment
+          // 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.
+    return ExtendedClassTypeEnvironment(
+        _classEnvironment, additionalParameters.toList());
+  }
+
+  @override
+  int recipeIndexOf(TypeParameter parameter) {
+    // Search in the extended type parameters first. They can shadow parameters
+    // from the class.
+    var i = _typeParameters.indexOf(parameter);
+    // Type parameter was found and should be a one based index. Zero refers to
+    // the original class rti that is the basis on this environment.
+    if (i >= 0) return i + 1;
+    i = _classEnvironment.recipeIndexOf(parameter);
+    // The type parameter bindings with the closest scope have the lowest
+    // indices. Since the parameter was found in the class binding the index
+    // must be offset by the number of extended parameters.
+    if (i > 0) return i + _typeParameters.length;
+    // Type parameter not found.
+    return -1;
+  }
+
+  List<TypeParameter> get extendedParameters =>
+      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 719b6c7..c633ba1 100644
--- a/pkg/dev_compiler/lib/src/kernel/type_recipe_generator.dart
+++ b/pkg/dev_compiler/lib/src/kernel/type_recipe_generator.dart
@@ -4,15 +4,48 @@
 
 import 'package:js_shared/synced/recipe_syntax.dart' show Recipe;
 import 'package:kernel/ast.dart';
+import 'package:kernel/core_types.dart';
 import 'package:path/path.dart' as p;
 
 import '../compiler/js_names.dart';
+import 'kernel_helpers.dart';
+import 'type_environment.dart';
+
+class TypeRecipeGenerator {
+  final _TypeRecipeVisitor _recipeVisitor;
+
+  TypeRecipeGenerator(CoreTypes coreTypes)
+      : _recipeVisitor =
+            _TypeRecipeVisitor(const EmptyTypeEnvironment(), coreTypes);
+
+  GeneratedRecipe recipeInEnvironment(
+      DartType type, DDCTypeEnvironment environment) {
+    var typeParameterFinder = TypeParameterTypeFinder();
+    type.accept(typeParameterFinder);
+    _recipeVisitor._typeEnvironment =
+        environment.prune(typeParameterFinder.found);
+    return GeneratedRecipe(
+        type.accept(_recipeVisitor), _recipeVisitor._typeEnvironment);
+  }
+
+  String interfaceTypeRecipe(Class node) =>
+      _recipeVisitor._interfaceTypeRecipe(node);
+}
 
 /// A visitor to generate type recipe strings from a [DartType].
 ///
 /// The recipes are used by the 'dart:_rti' library while running the compiled
 /// application.
-class TypeRecipeGenerator extends DartTypeVisitor<String> {
+class _TypeRecipeVisitor extends DartTypeVisitor<String> {
+  /// The type environment to evaluate recipes in.
+  ///
+  /// Used to determine the indices for type variables.
+  DDCTypeEnvironment _typeEnvironment;
+
+  final CoreTypes _coreTypes;
+
+  _TypeRecipeVisitor(this._typeEnvironment, this._coreTypes);
+
   @override
   String defaultDartType(DartType node) {
     return 'TODO';
@@ -26,11 +59,19 @@
 
   @override
   String visitInterfaceType(InterfaceType node) {
-    var recipe = interfaceTypeRecipe(node.classNode);
-    if (node.typeArguments.isEmpty) {
-      return '$recipe${_nullabilityRecipe(node)}';
+    // Generate the interface type recipe.
+    var recipeBuffer = StringBuffer(_interfaceTypeRecipe(node.classNode));
+    // Generate the recipes for all type arguments.
+    if (node.typeArguments.isNotEmpty) {
+      recipeBuffer.write(Recipe.startTypeArgumentsString);
+      recipeBuffer.writeAll(
+          node.typeArguments.map((typeArgument) => typeArgument.accept(this)),
+          Recipe.separatorString);
+      recipeBuffer.write(Recipe.endTypeArgumentsString);
     }
-    return 'TODO';
+    // Add nullability.
+    recipeBuffer.write(_nullabilityRecipe(node));
+    return recipeBuffer.toString();
   }
 
   @override
@@ -43,8 +84,10 @@
   String visitFunctionType(FunctionType node) => defaultDartType(node);
 
   @override
-  String visitTypeParameterType(TypeParameterType node) =>
-      defaultDartType(node);
+  String visitTypeParameterType(TypeParameterType node) {
+    var i = _typeEnvironment.recipeIndexOf(node.parameter);
+    return '$i${_nullabilityRecipe(node)}';
+  }
 
   @override
   String visitTypedefType(TypedefType node) => defaultDartType(node);
@@ -59,7 +102,8 @@
               '${_nullabilityRecipe(node)}';
 
   @override
-  String visitNullType(NullType node) => defaultDartType(node);
+  String visitNullType(NullType node) =>
+      _interfaceTypeRecipe(_coreTypes.deprecatedNullClass);
 
   @override
   String visitExtensionType(ExtensionType node) => defaultDartType(node);
@@ -69,14 +113,14 @@
       visitTypeParameterType(node.left);
 
   /// Returns the recipe for the interface type introduced by [cls].
-  static String interfaceTypeRecipe(Class cls) {
+  String _interfaceTypeRecipe(Class cls) {
     var path = p.withoutExtension(cls.enclosingLibrary.importUri.path);
     var library = pathToJSIdentifier(path);
     return '$library${Recipe.librarySeparatorString}${cls.name}';
   }
 
   /// Returns the recipe representation of [nullability].
-  static String _nullabilityRecipe(DartType type) {
+  String _nullabilityRecipe(DartType type) {
     switch (type.declaredNullability) {
       case Nullability.undetermined:
         if (type is TypeParameterType) {
@@ -96,3 +140,23 @@
     }
   }
 }
+
+/// Packages the type recipe and the environment needed to evaluate it at
+/// runtime.
+///
+/// Returned from [TypeRecipeGenerator.recipeInEnvironment].
+class GeneratedRecipe {
+  /// A type recipe that can be used to evaluate a type at runtime in the
+  /// [requiredEnvironment].
+  ///
+  /// For use with the dart:_rti library.
+  final String recipe;
+
+  /// The environment required to properly evaluate [recipe] within.
+  ///
+  /// This environment has been reduced down to be represented compactly with
+  /// only the necessary type parameters.
+  final DDCTypeEnvironment requiredEnvironment;
+
+  GeneratedRecipe(this.recipe, this.requiredEnvironment);
+}
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 8eef711..a6d1bec 100644
--- a/sdk/lib/_internal/js_dev_runtime/private/foreign_helper.dart
+++ b/sdk/lib/_internal/js_dev_runtime/private/foreign_helper.dart
@@ -4,6 +4,7 @@
 
 library dart._foreign_helper;
 
+import 'dart:_interceptors' show JSArray;
 import 'dart:_js_helper' show notNull;
 import 'dart:_js_shared_embedded_names' show JsBuiltin, JsGetName;
 import 'dart:_rti' show Rti;
@@ -298,12 +299,12 @@
 /// Returns the interceptor for [object].
 ///
 // TODO(nshahan) Replace calls at compile time?
-external getInterceptor(object);
+Object getInterceptor(object) => object;
 
 /// Returns the Rti object for the type for JavaScript arrays via JS-interop.
 ///
 // TODO(nshahan) Replace calls at compile time?
-external Object getJSArrayInteropRti();
+Object getJSArrayInteropRti() => TYPE_REF<JSArray>();
 
 /// Returns a raw reference to the JavaScript function which implements
 /// [function].