[dart2js] Remove nullability on type declaration for IR type variables.

The only nullable call to the JTypeVariable constructor was if the K-model had a Local as the typeDeclaration.

However, the K-model creates LocalTypeVariable entities for these instead of TypeVariable entities. The former is never added to the K- element map so they aren't copied over to the J-model up front:
https://github.com/dart-lang/sdk/blob/main/pkg/compiler/lib/src/kernel/element_map_impl.dart#L1531

Instead the corresponding JTypeVariable entities are added later when the closures are created:
https://github.com/dart-lang/sdk/blob/main/pkg/compiler/lib/src/js_model/element_map_impl.dart#L1871

Change-Id: If018fe8ca666695989b0f2075d837f8e6994f0fb
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/311060
Reviewed-by: Sigmund Cherem <sigmund@google.com>

Author: natebiggs

pkg/compiler/lib/src/elements/entities.dart

@@ -87,9 +87,7 @@ abstract class ClassEntity extends Entity {
 
 abstract class TypeVariableEntity extends Entity {
   /// The class or generic method that declared this type variable.
-  /// Is `null` for some generic functions and closures.
-  // TODO(sra): Figure out how to always have a [typeDeclaration].
-  Entity? get typeDeclaration;
+  Entity get typeDeclaration;
 
   /// The index of this type variable in the type variables of its
   /// [typeDeclaration].

pkg/compiler/lib/src/elements/types.dart

@@ -1660,7 +1660,7 @@ class _DartTypeToStringVisitor extends DartTypeVisitor<void, void> {
 
   @override
   void visitTypeVariableType(covariant TypeVariableType type, _) {
-    _identifier(type.element.typeDeclaration!.name!);
+    _identifier(type.element.typeDeclaration.name!);
     _token('.');
     _identifier(type.element.name!);
   }

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

@@ -533,7 +533,7 @@ class RuntimeTypesImpl
             .classInstantiationsOf(declaration)
             .map((InterfaceType interface) => interface.typeArguments[index]);
       } else {
-        return typeVariableTests.instantiationsOf(declaration!).map(
+        return typeVariableTests.instantiationsOf(declaration).map(
             (GenericInstantiation instantiation) =>
                 instantiation.typeArguments[index]);
       }

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

@@ -309,7 +309,7 @@ class TypeVariableTests {
     ///
     void registerDependencies(RtiNode node, DartType type) {
       type.forEachTypeVariable((TypeVariableType typeVariable) {
-        final typeDeclaration = typeVariable.element.typeDeclaration!;
+        final typeDeclaration = typeVariable.element.typeDeclaration;
         if (typeDeclaration is ClassEntity) {
           node.addDependency(_getClassNode(typeDeclaration));
         } else {
@@ -326,7 +326,7 @@ class TypeVariableTests {
       }
 
       void onTypeVariable(TypeVariableType type) {
-        final declaration = type.element.typeDeclaration!;
+        final declaration = type.element.typeDeclaration;
         if (declaration is ClassEntity) {
           node.addDependency(_getClassNode(declaration));
         } else {
@@ -470,7 +470,7 @@ class TypeVariableTests {
   void _propagateTests() {
     void processTypeVariableType(TypeVariableType type) {
       TypeVariableEntity variable = type.element;
-      final typeDeclaration = variable.typeDeclaration!;
+      final typeDeclaration = variable.typeDeclaration;
       if (typeDeclaration is ClassEntity) {
         _getClassNode(typeDeclaration).markTest();
       } else {
@@ -552,7 +552,7 @@ class TypeVariableTests {
 
   void _addImplicitChecksViaInstantiation(TypeVariableType variable) {
     TypeVariableEntity entity = variable.element;
-    final declaration = entity.typeDeclaration!;
+    final declaration = entity.typeDeclaration;
     if (declaration is ClassEntity) {
       classInstantiationsOf(declaration).forEach((InterfaceType type) {
         _addImplicitCheck(type.typeArguments[entity.index]);
@@ -965,7 +965,6 @@ class RuntimeTypesNeedBuilderImpl implements RuntimeTypesNeedBuilder {
   @override
   void registerTypeVariableLiteral(TypeVariableType variable) {
     final typeDeclaration = variable.element.typeDeclaration;
-    assert(typeDeclaration != null);
     if (typeDeclaration is ClassEntity) {
       registerClassUsingTypeVariableLiteral(typeDeclaration);
     } else if (typeDeclaration is FunctionEntity) {
@@ -1060,7 +1059,7 @@ class RuntimeTypesNeedBuilderImpl implements RuntimeTypesNeedBuilder {
             potentiallyNeedTypeArguments(function);
           }
           functionType.forEachTypeVariable((TypeVariableType typeVariable) {
-            final typeDeclaration = typeVariable.element.typeDeclaration!;
+            final typeDeclaration = typeVariable.element.typeDeclaration;
             if (!processedEntities.contains(typeDeclaration)) {
               potentiallyNeedTypeArguments(typeDeclaration);
             }
@@ -1100,7 +1099,7 @@ class RuntimeTypesNeedBuilderImpl implements RuntimeTypesNeedBuilder {
           type.forEachTypeVariable((TypeVariableType typeVariable) {
             // This handles checks against type variables and function types
             // containing type variables.
-            final typeDeclaration = typeVariable.element.typeDeclaration!;
+            final typeDeclaration = typeVariable.element.typeDeclaration;
             potentiallyNeedTypeArguments(typeDeclaration);
           });
           if (type is FunctionType) {
@@ -1295,7 +1294,7 @@ class RuntimeTypesNeedBuilderImpl implements RuntimeTypesNeedBuilder {
         FunctionType functionType =
             _elementEnvironment.getLocalFunctionType(function);
         functionType.forEachTypeVariable((TypeVariableType typeVariable) {
-          final typeDeclaration = typeVariable.element.typeDeclaration!;
+          final typeDeclaration = typeVariable.element.typeDeclaration;
           if (!processedEntities.contains(typeDeclaration)) {
             potentiallyNeedTypeArguments(typeDeclaration);
           }

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

@@ -667,7 +667,7 @@ class _RecipeToIdentifier extends DartTypeVisitor<void, Null> {
 
   @override
   void visitTypeVariableType(covariant TypeVariableType type, _) {
-    _identifier(type.element.typeDeclaration!.name!);
+    _identifier(type.element.typeDeclaration.name!);
     _identifier(type.element.name!);
   }
 

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

@@ -270,18 +270,17 @@ class JsKernelToElementMap implements JsToElementMap, IrToElementMap {
         final cls = oldTypeVariable.typeDeclaration as IndexedClass;
         newTypeDeclaration = classes.getEntity(cls.classIndex);
         // TODO(johnniwinther): Skip type variables of unused classes.
-      } else if (oldTypeVariable.typeDeclaration is MemberEntity) {
+      } else {
+        assert(oldTypeVariable.typeDeclaration is MemberEntity);
         final member = oldTypeVariable.typeDeclaration as IndexedMember;
         newTypeDeclaration = members.getEntity(member.memberIndex);
         if (newTypeDeclaration == null) {
           typeVariables.skipIndex(typeVariableIndex);
           continue;
         }
-      } else {
-        assert(oldTypeVariable.typeDeclaration is Local);
       }
       IndexedTypeVariable newTypeVariable = createTypeVariable(
-              newTypeDeclaration, oldTypeVariable.name!, oldTypeVariable.index)
+              newTypeDeclaration!, oldTypeVariable.name!, oldTypeVariable.index)
           as IndexedTypeVariable;
       typeVariableMap[oldTypeVariableData.node] =
           typeVariables.register<IndexedTypeVariable, JTypeVariableData>(
@@ -1552,7 +1551,7 @@ class JsKernelToElementMap implements JsToElementMap, IrToElementMap {
   }
 
   TypeVariableEntity createTypeVariable(
-      Entity? typeDeclaration, String name, int index) {
+      Entity typeDeclaration, String name, int index) {
     return JTypeVariable(typeDeclaration, name, index);
   }
 

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

@@ -753,21 +753,27 @@ class JSignatureMethod extends JMethod {
 }
 
 /// Enum used for identifying [JTypeVariable] variants in serialization.
-enum JTypeVariableKind { cls, member, local }
+///
+/// [JLocalTypeVariable] in the K-world can contain a [Local] as its
+/// `typeDeclaration` but those are never serialized. When converted to the
+/// J-world they use a [JClosureCallMethod] as [JTypeVariable.typeDeclaration].
+enum JTypeVariableKind { cls, member }
 
 class JTypeVariable extends IndexedTypeVariable {
   /// Tag used for identifying serialized [JTypeVariable] objects in a
   /// debugging data stream.
   static const String tag = 'type-variable';
 
   @override
-  final Entity? typeDeclaration;
+  final Entity typeDeclaration;
   @override
   final String name;
   @override
   final int index;
 
-  JTypeVariable(this.typeDeclaration, this.name, this.index);
+  JTypeVariable(this.typeDeclaration, this.name, this.index) {
+    assert(typeDeclaration is ClassEntity || typeDeclaration is MemberEntity);
+  }
 
   /// Deserializes a [JTypeVariable] object from [source].
   factory JTypeVariable.readFromDataSource(DataSourceReader source) {
@@ -781,12 +787,6 @@ class JTypeVariable extends IndexedTypeVariable {
       case JTypeVariableKind.member:
         typeDeclaration = source.readMember();
         break;
-      case JTypeVariableKind.local:
-        // Type variables declared by local functions don't point to their
-        // declaration, since the corresponding closure call methods is created
-        // after the type variable.
-        // TODO(johnniwinther): Fix this.
-        break;
     }
     String name = source.readString();
     int index = source.readInt();
@@ -804,8 +804,6 @@ class JTypeVariable extends IndexedTypeVariable {
     } else if (declaration is MemberEntity) {
       sink.writeEnum(JTypeVariableKind.member);
       sink.writeMember(declaration);
-    } else if (declaration == null) {
-      sink.writeEnum(JTypeVariableKind.local);
     } else {
       throw UnsupportedError(
           "Unexpected type variable declarer $typeDeclaration.");
@@ -817,7 +815,7 @@ class JTypeVariable extends IndexedTypeVariable {
 
   @override
   String toString() =>
-      '${jsElementPrefix}type_variable(${typeDeclaration?.name}.$name)';
+      '${jsElementPrefix}type_variable(${typeDeclaration.name}.$name)';
 }
 
 class JLocalFunction implements Local {