[dart2js] Support conversion of local function type variables from K to J model

This CL adds support for converting local function type variables from
the K model to the J model. The entity use for the J model type variables
isn't created before the closure classes and closure call methods have
been created. Therefore, the [ClosureData] is now registered
with the [JsToFrontendMap] object, once computed, allowing conversion of
local function type variables. Conversion of [BackendUsage] is moved
after closure creation because [RuntimeTypeUse] can refer to local
function type variables.

Closes #42088

Change-Id: Ifc00e69b5db0dd05710ea97017c41e8c7f5e520e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/153080
Reviewed-by: Mayank Patke <[email protected]>
Commit-Queue: Johnni Winther <[email protected]>

Author: johnniwinther

pkg/compiler/lib/src/js_model/js_world_builder.dart

@@ -62,8 +62,6 @@ class JsClosedWorldBuilder {
       OutputUnitData kOutputUnitData) {
     JsToFrontendMap map = new JsToFrontendMapImpl(_elementMap);
 
-    BackendUsage backendUsage =
-        _convertBackendUsage(map, closedWorld.backendUsage);
     NativeData nativeData = _convertNativeData(map, closedWorld.nativeData);
     _elementMap.nativeData = nativeData;
     InterceptorData interceptorData =
@@ -162,7 +160,7 @@ class JsClosedWorldBuilder {
       }
 
       RuntimeTypesNeedImpl jRtiNeed =
-          _convertRuntimeTypesNeed(map, backendUsage, kernelRtiNeed);
+          _convertRuntimeTypesNeed(map, kernelRtiNeed);
       closureData = _closureDataBuilder.createClosureEntities(
           this,
           map.toBackendMemberMap(closureModels, identity),
@@ -189,6 +187,11 @@ class JsClosedWorldBuilder {
       rtiNeed = jRtiNeed;
     }
 
+    map.registerClosureData(closureData);
+
+    BackendUsage backendUsage =
+        _convertBackendUsage(map, closedWorld.backendUsage);
+
     NoSuchMethodDataImpl oldNoSuchMethodData = closedWorld.noSuchMethodData;
     NoSuchMethodData noSuchMethodData = new NoSuchMethodDataImpl(
         map.toBackendFunctionSet(oldNoSuchMethodData.throwingImpls),
@@ -378,8 +381,8 @@ class JsClosedWorldBuilder {
             interceptorData.classesMixedIntoInterceptedClasses));
   }
 
-  RuntimeTypesNeed _convertRuntimeTypesNeed(JsToFrontendMap map,
-      BackendUsage backendUsage, RuntimeTypesNeedImpl rtiNeed) {
+  RuntimeTypesNeed _convertRuntimeTypesNeed(
+      JsToFrontendMap map, RuntimeTypesNeedImpl rtiNeed) {
     Set<ClassEntity> classesNeedingTypeArguments =
         map.toBackendClassSet(rtiNeed.classesNeedingTypeArguments);
     Set<FunctionEntity> methodsNeedingTypeArguments =
@@ -597,6 +600,13 @@ abstract class JsToFrontendMap {
 
   ConstantValue toBackendConstant(ConstantValue value, {bool allowNull: false});
 
+  /// Register [closureData] with this map.
+  ///
+  /// [ClosureData] holds the relation between local function and the backend
+  /// entities. Before this has been registered, type variables of local
+  /// functions cannot be converted into backend equivalents.
+  void registerClosureData(ClosureData closureData);
+
   Set<LibraryEntity> toBackendLibrarySet(Iterable<LibraryEntity> set) {
     return set.map(toBackendLibrary).toSet();
   }
@@ -671,6 +681,7 @@ Map<K, V2> convertMap<K, V1, V2>(
 
 class JsToFrontendMapImpl extends JsToFrontendMap {
   final JsKernelToElementMap _backend;
+  ClosureData _closureData;
 
   JsToFrontendMapImpl(this._backend);
 
@@ -707,10 +718,23 @@ class JsToFrontendMapImpl extends JsToFrontendMap {
     return _backend.members.getEntity(member.memberIndex);
   }
 
+  @override
+  void registerClosureData(ClosureData closureData) {
+    assert(_closureData == null, "Closure data has already been registered.");
+    _closureData = closureData;
+  }
+
   TypeVariableEntity toBackendTypeVariable(TypeVariableEntity typeVariable) {
     if (typeVariable is KLocalTypeVariable) {
-      failedAt(
-          typeVariable, "Local function type variables are not supported.");
+      if (_closureData == null) {
+        failedAt(
+            typeVariable, "Local function type variables are not supported.");
+      }
+      ClosureRepresentationInfo info =
+          _closureData.getClosureInfo(typeVariable.typeDeclaration.node);
+      return _backend.elementEnvironment
+          .getFunctionTypeVariables(info.callMethod)[typeVariable.index]
+          .element;
     }
     IndexedTypeVariable indexedTypeVariable = typeVariable;
     return _backend.typeVariables

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

@@ -281,7 +281,7 @@ class KLocalFunction implements Local {
 
 class KLocalTypeVariable implements TypeVariableEntity {
   @override
-  final Entity typeDeclaration;
+  final KLocalFunction typeDeclaration;
   @override
   final String name;
   @override

tests/dart2js/42088_test.dart

@@ -0,0 +1,14 @@
+// Copyright (c) 2020, 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.
+
+// Regression test for issue 42088.
+
+class Foo<T> {}
+
+void main() {
+  var f = <T>() => Foo<T>().runtimeType;
+
+  print(f<int>());
+  print(f<String>());
+}

tests/dart2js_2/42088_test.dart

@@ -0,0 +1,14 @@
+// Copyright (c) 2020, 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.
+
+// Regression test for issue 42088.
+
+class Foo<T> {}
+
+void main() {
+  var f = <T>() => Foo<T>().runtimeType;
+
+  print(f<int>());
+  print(f<String>());
+}