Forbid native JsTypes from being sealed or directly subtyping a sealed type.

This also adds the sealed bit to the J2CL AST and populates it in both the javac
and Kotlin frontends. It is _not_ populated in the JDT frontend as the version
we currently use lacks it.

PiperOrigin-RevId: 886501391

Author: kevinoconnor7

transpiler/java/com/google/j2cl/transpiler/ast/TypeDeclaration.java

@@ -277,6 +277,8 @@ public boolean isAbstract() {
 
   public abstract boolean isFinal();
 
+  public abstract boolean isSealed();
+
   // TODO(b/322906767): Remove when the bug is fixed.
   private static final boolean PRESERVE_EQUALS_FOR_JSTYPE_INTERFACE =
       "true"
@@ -820,6 +822,7 @@ public static Builder newBuilder() {
         .setAnnotation(false)
         .setCapturingEnclosingInstance(false)
         .setFinal(false)
+        .setSealed(false)
         .setFunctionalInterface(false)
         .setAnnotationsFactory(ImmutableList::of)
         .setJsFunctionInterface(false)
@@ -889,6 +892,8 @@ public abstract Builder setEnclosingMethodDescriptorFactory(
 
     public abstract Builder setFinal(boolean isFinal);
 
+    public abstract Builder setSealed(boolean isSealed);
+
     public abstract Builder setFunctionalInterface(boolean isFunctionalInterface);
 
     public abstract Builder setOrigin(Origin origin);

transpiler/java/com/google/j2cl/transpiler/frontend/javac/JavaEnvironment.java

@@ -1370,6 +1370,7 @@ TypeDeclaration createTypeDeclaration(final TypeElement typeElement) {
         .setAnnotation(isAnnotation(typeElement))
         .setCapturingEnclosingInstance(capturesEnclosingInstance((ClassSymbol) typeElement))
         .setFinal(isFinal)
+        .setSealed(isSealed(typeElement))
         .setFunctionalInterface(isFunctionalInterface(typeElement.asType()))
         .setJsFunctionInterface(JsInteropUtils.isJsFunction(typeElement))
         .setAnnotationsFactory(() -> createAnnotations(typeElement, isNullMarked))
@@ -1599,6 +1600,10 @@ private static boolean isFinal(Element element) {
     return element.getModifiers().contains(Modifier.FINAL);
   }
 
+  private static boolean isSealed(Element element) {
+    return element.getModifiers().contains(Modifier.SEALED);
+  }
+
   private static boolean isVolatile(Element element) {
     return element.getModifiers().contains(Modifier.VOLATILE);
   }

transpiler/java/com/google/j2cl/transpiler/frontend/kotlin/KotlinEnvironment.kt

@@ -63,6 +63,7 @@ import com.google.j2cl.transpiler.frontend.kotlin.ir.isJsType
 import com.google.j2cl.transpiler.frontend.kotlin.ir.isKFunctionOrKSuspendFunction
 import com.google.j2cl.transpiler.frontend.kotlin.ir.isNative
 import com.google.j2cl.transpiler.frontend.kotlin.ir.isNativeJsField
+import com.google.j2cl.transpiler.frontend.kotlin.ir.isSealed
 import com.google.j2cl.transpiler.frontend.kotlin.ir.j2clKind
 import com.google.j2cl.transpiler.frontend.kotlin.ir.j2clVisibility
 import com.google.j2cl.transpiler.frontend.kotlin.ir.jsName
@@ -274,6 +275,7 @@ internal class KotlinEnvironment(
         .setFunctionalInterface(irClass.isFunctionalInterface)
         .setHasAbstractModifier(irClass.isAbstract)
         .setFinal(irClass.isFinal)
+        .setSealed(irClass.isSealed)
         .setLocal(irClass.isLocal && !irClass.isAnonymousObject)
         .setAnonymous(irClass.isAnonymousObject)
         .setJsType(irClass.isJsType)
@@ -971,16 +973,15 @@ private fun remapDeclarationTypeVarianceOntoArguments(
   arguments: List<IrTypeArgument>,
   originalTypeParams: List<IrTypeParameter>,
   replacementTypeParams: List<IrTypeParameter>,
-) =
-  arguments.mapIndexed { index, argument ->
-    if (
-      argument is IrTypeProjection &&
-        originalTypeParams[index].variance != Variance.INVARIANT &&
-        replacementTypeParams[index].variance == Variance.INVARIANT &&
-        argument.variance == Variance.INVARIANT
-    ) {
-      makeTypeProjection(argument.type, originalTypeParams[index].variance)
-    } else {
-      argument
-    }
+) = arguments.mapIndexed { index, argument ->
+  if (
+    argument is IrTypeProjection &&
+      originalTypeParams[index].variance != Variance.INVARIANT &&
+      replacementTypeParams[index].variance == Variance.INVARIANT &&
+      argument.variance == Variance.INVARIANT
+  ) {
+    makeTypeProjection(argument.type, originalTypeParams[index].variance)
+  } else {
+    argument
   }
+}

transpiler/java/com/google/j2cl/transpiler/frontend/kotlin/ir/IrUtils.kt

@@ -363,12 +363,11 @@ private fun IrType.resolveWithTypeParameterMapping(
     if (arguments.isEmpty()) {
       return this
     }
-    val resolvedArguments =
-      arguments.map {
-        it.typeOrNull?.resolveWithTypeParameterMapping(parameterTypeMapping)?.let { type ->
-          makeTypeProjection(type, type.variance)
-        } ?: it
-      }
+    val resolvedArguments = arguments.map {
+      it.typeOrNull?.resolveWithTypeParameterMapping(parameterTypeMapping)?.let { type ->
+        makeTypeProjection(type, type.variance)
+      } ?: it
+    }
     return toBuilder().apply { arguments = resolvedArguments }.buildSimpleType()
   }
   return this
@@ -540,6 +539,9 @@ val IrClass.isAbstract: Boolean
 val IrClass.isFinal: Boolean
   get() = modality == Modality.FINAL
 
+val IrClass.isSealed: Boolean
+  get() = modality == Modality.SEALED
+
 val IrClass.isFromSource: Boolean
   get() = source.containingFile != SourceFile.NO_SOURCE_FILE
 

transpiler/java/com/google/j2cl/transpiler/passes/JsInteropRestrictionsChecker.java

@@ -1555,6 +1555,26 @@ private boolean checkNativeJsType(Type type) {
       return false;
     }
 
+    if (typeDeclaration.isSealed()) {
+      problems.error(
+          type.getSourcePosition(),
+          "Sealed %s '%s' cannot be a native JsType.",
+          typeDeclaration.isInterface() ? "interface" : "class",
+          readableDescription);
+    }
+
+    type.getSuperTypesStream()
+        .filter(typeDescriptor -> typeDescriptor.getTypeDeclaration().isSealed())
+        .forEach(
+            superType ->
+                problems.error(
+                    type.getSourcePosition(),
+                    "Native JsType '%s' cannot %s sealed %s '%s'.",
+                    readableDescription,
+                    type.isInterface() || superType.isClass() ? "extend" : "implement",
+                    superType.isInterface() ? "interface" : "class",
+                    superType.getReadableDescription()));
+
     type.getSuperTypesStream()
         .filter(Predicates.not(TypeDescriptors::isJavaLangObject))
         .filter(Predicates.not(TypeDescriptor::isNative))

transpiler/javatests/com/google/j2cl/transpiler/JsInteropRestrictionsCheckerTest.java

@@ -3438,6 +3438,46 @@ default void someMethod() {}
                 + "'void Interface.someOtherMethod()'.");
   }
 
+  public void testSealedClassExtendingNativeJsTypeSucceeds() {
+    assertTranspileSucceeds(
+            "test.Buggy",
+            """
+            import jsinterop.annotations.*;
+            @JsType(isNative=true)
+            class NativeBase {}
+            sealed class SealedClass extends NativeBase { @JsConstructor SealedClass() {} }
+            final class Subtype extends SealedClass { @JsConstructor Subtype() {} }
+            """)
+        .assertNoWarnings();
+  }
+
+  public void testNativeJsTypeSealedTypeFails() {
+    assertTranspileFails(
+            "test.Foo",
+            """
+            import jsinterop.annotations.*;
+            @JsType(isNative = true)
+            sealed class SealedNativeClass {}
+            @JsType(isNative = true)
+            sealed interface SealedNativeInterface {}
+            @JsType(isNative = true)
+            final class NativeSubtype extends SealedNativeClass implements SealedNativeInterface { @JsConstructor NativeSubtype() {} }
+            @JsType(isNative = true)
+            sealed class SealedNativeSubtype extends SealedNativeClass implements SealedNativeInterface {}
+            final class FinalSubtype extends SealedNativeSubtype { @JsConstructor FinalSubtype() {} }
+            """)
+        .assertErrorsWithoutSourcePosition(
+            "Sealed class 'SealedNativeClass' cannot be a native JsType.",
+            "Sealed interface 'SealedNativeInterface' cannot be a native JsType.",
+            "Native JsType 'NativeSubtype' cannot implement sealed interface"
+                + " 'SealedNativeInterface'.",
+            "Native JsType 'NativeSubtype' cannot extend sealed class 'SealedNativeClass'.",
+            "Sealed class 'SealedNativeSubtype' cannot be a native JsType.",
+            "Native JsType 'SealedNativeSubtype' cannot implement sealed interface"
+                + " 'SealedNativeInterface'.",
+            "Native JsType 'SealedNativeSubtype' cannot extend sealed class 'SealedNativeClass'.");
+  }
+
   public void testJsOptionalSucceeds() {
     newTesterWithDefaults()
         .addCompilationUnit(