[dart2js] New RTI: Replace $ti._eval$1("1") with $ti._rest[0].

Change-Id: I518a92317f7b3168a02820ee0a5af132ce56568c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/119502
Reviewed-by: Stephen Adams <sra@google.com>

Author: fishythefish

pkg/compiler/lib/src/js_backend/runtime_types_new.dart

@@ -141,8 +141,6 @@ class _RecipeGenerator implements DartTypeVisitor<void, void> {
   final List<jsAst.Literal> _fragments = [];
   final List<int> _codes = [];
 
-  RuntimeTypesNeed get _rtiNeed => _encoder._rtiNeed;
-
   _RecipeGenerator(
       this._encoder, this._emitter, this._environment, this._recipe,
       {this.metadata = false, this.hackTypeVariablesToAny = false});
@@ -260,26 +258,14 @@ class _RecipeGenerator implements DartTypeVisitor<void, void> {
       }
     }
     if (environment is FullTypeEnvironmentStructure) {
-      int i = environment.bindings.indexOf(type);
-      if (i >= 0) {
-        // Indexes are 1-based since '0' encodes using the entire type for the
-        // singleton structure.
-        _emitInteger(i + 1);
-        return;
-      }
-
-      int index = _indexIntoClassTypeVariables(type);
+      int index = indexTypeVariable(
+          _closedWorld, _rtiSubstitutions, environment, type,
+          metadata: metadata);
       if (index != null) {
-        // We should only observe erased type arguments if we're generating
-        // subtype metadata.
-        assert(metadata ||
-            _rtiNeed.classNeedsTypeArguments(environment.classType.element));
-
-        // Indexed class type variables come after the bound function type
-        // variables.
-        _emitInteger(1 + environment.bindings.length + index);
+        _emitInteger(index);
         return;
       }
+
       jsAst.Name name = _emitter.typeVariableAccessNewRti(type.element);
       _emitName(name);
       typeVariables.add(type);
@@ -290,35 +276,6 @@ class _RecipeGenerator implements DartTypeVisitor<void, void> {
     '`$type`'.codeUnits.forEach(_emitCode);
   }
 
-  int /*?*/ _indexIntoClassTypeVariables(TypeVariableType variable) {
-    TypeVariableEntity element = variable.element;
-    ClassEntity cls = element.typeDeclaration;
-
-    if (metadata) {
-      TypeEnvironmentStructure environment = _environment;
-      if (environment is FullTypeEnvironmentStructure) {
-        if (identical(environment.classType.element, cls)) {
-          return element.index;
-        }
-      }
-    }
-
-    // TODO(sra): We might be in a context where the class type variable has an
-    // index, even though in the general case it is not at a specific index.
-
-    ClassHierarchy classHierarchy = _closedWorld.classHierarchy;
-    var test = mustCheckAllSubtypes(_closedWorld, cls)
-        ? classHierarchy.anyStrictSubtypeOf
-        : classHierarchy.anyStrictSubclassOf;
-
-    if (test(cls, (ClassEntity subclass) {
-      return !_rtiSubstitutions.isTrivialSubstitution(subclass, cls);
-    })) {
-      return null;
-    }
-    return element.index;
-  }
-
   @override
   void visitFunctionTypeVariable(FunctionTypeVariable type, _) {
     int position = functionTypeVariables.indexOf(type);
@@ -479,6 +436,49 @@ bool mustCheckAllSubtypes(JClosedWorld world, ClassEntity cls) =>
     world.isUsedAsMixin(cls) ||
     world.extractTypeArgumentsInterfacesNewRti.contains(cls);
 
+int indexTypeVariable(
+    JClosedWorld world,
+    RuntimeTypesSubstitutions rtiSubstitutions,
+    FullTypeEnvironmentStructure environment,
+    TypeVariableType type,
+    {bool metadata = false}) {
+  int i = environment.bindings.indexOf(type);
+  if (i >= 0) {
+    // Indices are 1-based since '0' encodes using the entire type for the
+    // singleton structure.
+    return i + 1;
+  }
+
+  TypeVariableEntity element = type.element;
+  ClassEntity cls = element.typeDeclaration;
+
+  if (metadata) {
+    if (identical(environment.classType.element, cls)) {
+      // Indexed class type variables come after the bound function type
+      // variables.
+      return 1 + environment.bindings.length + element.index;
+    }
+  }
+
+  // TODO(sra): We might be in a context where the class type variable has an
+  // index, even though in the general case it is not at a specific index.
+
+  ClassHierarchy classHierarchy = world.classHierarchy;
+  var test = mustCheckAllSubtypes(world, cls)
+      ? classHierarchy.anyStrictSubtypeOf
+      : classHierarchy.anyStrictSubclassOf;
+  if (test(cls, (ClassEntity subclass) {
+    return !rtiSubstitutions.isTrivialSubstitution(subclass, cls);
+  })) {
+    return null;
+  }
+
+  assert(world.rtiNeed.classNeedsTypeArguments(environment.classType.element));
+  // Indexed class type variables come after the bound function type
+  // variables.
+  return 1 + environment.bindings.length + element.index;
+}
+
 class _RulesetEntry {
   Set<InterfaceType> _supertypes = {};
   Map<TypeVariableType, DartType> _typeVariables = {};

pkg/compiler/lib/src/ssa/codegen.dart

@@ -28,9 +28,10 @@ import '../js_backend/namer.dart' show ModularNamer;
 import '../js_backend/runtime_types.dart';
 import '../js_backend/runtime_types_codegen.dart';
 import '../js_backend/runtime_types_new.dart'
-    show RecipeEncoder, RecipeEncoding;
+    show RecipeEncoder, RecipeEncoding, indexTypeVariable;
 import '../js_emitter/code_emitter_task.dart' show ModularEmitter;
 import '../js_model/elements.dart' show JGeneratorBody;
+import '../js_model/type_recipe.dart';
 import '../native/behavior.dart';
 import '../options.dart';
 import '../tracer.dart';
@@ -3472,6 +3473,37 @@ class SsaCodeGenerator implements HVisitor, HBlockInformationVisitor {
     // Call `env._eval("recipe")`.
     use(node.inputs[0]);
     js.Expression environment = pop();
+
+    // Instead of generating `env._eval("$n")`, generate appropriate field
+    // accesses where possible.
+    TypeEnvironmentStructure envStructure = node.envStructure;
+    TypeRecipe typeExpression = node.typeExpression;
+    if (envStructure is FullTypeEnvironmentStructure &&
+        typeExpression is TypeExpressionRecipe) {
+      if (typeExpression.type.isTypeVariable) {
+        TypeVariableType type = typeExpression.type;
+        int index = indexTypeVariable(
+            _closedWorld, _rtiSubstitutions, envStructure, type);
+        if (index != null) {
+          assert(index >= 1);
+          List<TypeVariableType> bindings = envStructure.bindings;
+          if (bindings.isNotEmpty) {
+            // If the environment is a binding RTI, we should never index past
+            // its length (i.e. into its base), since in that case, we could
+            // eval against the base directly.
+            assert(index <= bindings.length);
+          }
+          js.Expression access = js.js('#.#[#]', [
+            environment,
+            _namer.instanceFieldPropertyName(_commonElements.rtiRestField),
+            js.number(index - 1),
+          ]);
+          push(access.withSourceInformation(node.sourceInformation));
+          return;
+        }
+      }
+    }
+
     RecipeEncoding encoding = _rtiRecipeEncoder.encodeRecipe(
         _emitter, node.envStructure, node.typeExpression);
     js.Expression recipe = encoding.recipe;