scala-js
diff --git a/‎linker/shared/src/main/scala/org/scalajs/linker/checker/IRChecker.scala
Lines changed: 36 additions & 2 deletions b/‎linker/shared/src/main/scala/org/scalajs/linker/checker/IRChecker.scala
Lines changed: 36 additions & 2 deletions
diff --git a/‎linker/shared/src/test/scala/org/scalajs/linker/IRCheckerTest.scala
Lines changed: 53 additions & 0 deletions b/‎linker/shared/src/test/scala/org/scalajs/linker/IRCheckerTest.scala
Lines changed: 53 additions & 0 deletions
@@ -253,7 +253,37 @@ private final class IRChecker(unit: LinkingUnit, reporter: ErrorReporter) {
               _:JSSuperSelect | _:JSGlobalRef =>
         }
         typecheckExpr(lhs, env)
-        typecheckExpect(rhs, env, lhs.tpe)
+
+        val expectedRhsTpe = lhs match {
+          case ArraySelect(array, _) =>
+            /* Array assignments are unsound due to covariance of arrays
+             * To maintain the subtyping relationship in the IR, we have to
+             * allow assignments of any type to
+             * - Array[Object] (that's expected)
+             * - and its subtypes (that's not expected)
+             */
+
+            array.tpe match {
+              case ArrayType(ArrayTypeRef(PrimRef(tpe), 1), _) =>
+                // for primitive arrays, only allow assignment of that primitive.
+                tpe
+
+              case _ =>
+                /* All other types are either
+                 * - Subtypes of Array[Object] (including null / nothing)
+                 *   Recall: `Array[Array[A]] <: Array[Object]` even for primitive `A`.
+                 * - Ill typed IR
+                 *   (in which case typechecking the lhs above will emit an error).
+                 *
+                 * Allow any rhs.
+                 */
+                AnyType
+            }
+
+          case _ => lhs.tpe
+        }
+
+        typecheckExpect(rhs, env, expectedRhsTpe)
 
       case Return(expr, label) =>
         val returnType = env.returnTypes(label.name)
@@ -499,13 +529,17 @@ private final class IRChecker(unit: LinkingUnit, reporter: ErrorReporter) {
 
       case ArrayLength(array) =>
         typecheckExpr(array, env)
-        if (!array.tpe.isInstanceOf[ArrayType])
+        if (array.tpe != NullType &&
+            array.tpe != NothingType &&
+            !array.tpe.isInstanceOf[ArrayType])
           reportError(i"Array type expected but ${array.tpe} found")
 
       case ArraySelect(array, index) =>
         typecheckExpect(index, env, IntType)
         typecheckExpr(array, env)
         array.tpe match {
+          case NothingType => // ok
+          case NullType => // will NPE, but allowed.
           case arrayType: ArrayType =>
             if (tree.tpe != arrayElemType(arrayType))
               reportError(i"Array select of array type $arrayType typed as ${tree.tpe}")
 
@@ -253,6 +253,59 @@ class IRCheckerTest {
     }
   }
 
+  @Test
+  def arrayOpsNullOrNothing(): AsyncResult = await {
+    val classDefs = Seq(
+      mainTestClassDef(
+        Block(
+          ArraySelect(Null(), int(1))(NothingType),
+          ArrayLength(Null()),
+          ArraySelect(Throw(Null()), int(1))(NothingType),
+          ArrayLength(Throw(Null()))
+        )
+      )
+    )
+
+    testLinkNoIRError(classDefs, MainTestModuleInitializers)
+  }
+
+  @Test
+  def arrayAssignCovariant(): AsyncResult = await {
+    val classDefs = Seq(
+      classDef("Foo", superClass = Some(ObjectClass)),
+      mainTestClassDef(
+        Assign(
+          ArraySelect(
+            ArrayValue(ArrayTypeRef.of(ClassRef("Foo")), Nil),
+            int(1)
+          )(ClassType("Foo", true)),
+          int(1) // not a Foo, but OK.
+        )
+      )
+    )
+
+    testLinkNoIRError(classDefs, MainTestModuleInitializers)
+  }
+
+  @Test
+  def arrayNoAssignCovariantPrimitive(): AsyncResult = await {
+    val classDefs = Seq(
+      mainTestClassDef(
+        Assign(
+          ArraySelect(
+            ArrayValue(ArrayTypeRef.of(IntRef), Nil),
+            int(1)
+          )(IntType),
+          str("foo")
+        )
+      )
+    )
+
+    for (log <- testLinkIRErrors(classDefs, MainTestModuleInitializers)) yield {
+      log.assertContainsError("int expected but string found for tree of type")
+    }
+  }
+
 }
 
 object IRCheckerTest {