Introduce a CheckedBehavior for StringIndexOutOfBoundsException.

Fundamentally, the primitive operation that causes language-
mandated `StringIndexOutOfBoundsException`s is `String.charAt`.
In order for the linker to recognize it and conditionally apply
checked behavior semantics to it, we introduce a new IR
`BinaryOp.String_charAt` for that operation.

We use a compiler back-end hack to inject that IR node as the body
of `String.charAt`. Using a dedicated primitive method in
`scalajs.runtime`, like we did for `identityHashCode`, would not
work so well here, as we want the binary operator to manipulate a
*primitive* `StringType`, not a `ClassType(BoxedStringClass)`.

For derived methods that are implemented on top of JS primitives,
namely `codePointAt` and `substring`, we use a trick similar to
what we did in `j.u.Arrays`: we introduce carefully-chosen no-op
calls to `charAt`, with the only purpose of checking bounds, before
delegating to the JS methods. Since `s.length()` is not known to be
pure by the optimizer, we use clever tricks not to call it in the
bounds checks of `substring`.

Author: sjrd

compiler/src/main/scala/org/scalajs/nscplugin/GenJSCode.scala

@@ -2236,7 +2236,10 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
           isJSFunctionDef(currentClassSym)) {
         val flags = js.MemberFlags.empty.withNamespace(namespace)
         val body = {
-          if (isImplClass(currentClassSym)) {
+          if (currentClassSym.get == HackedStringClass && methodName.name == charAtMethodName) {
+            // Hijack the body of String.charAt and replace it with a String_charAt binary op
+            js.BinaryOp(js.BinaryOp.String_charAt, genThis(), jsParams.head.ref)
+          } else if (isImplClass(currentClassSym)) {
             val thisParam = jsParams.head
             withScopedVars(
                 thisLocalVarIdent := Some(thisParam.name)
@@ -7059,6 +7062,9 @@ private object GenJSCode {
   private val ObjectArgConstructorName =
     MethodName.constructor(List(jstpe.ClassRef(ir.Names.ObjectClass)))
 
+  private val charAtMethodName =
+    MethodName("charAt", List(jstpe.IntRef), jstpe.CharRef)
+
   private val thisOriginalName = OriginalName("this")
 
   private object BlockOrAlone {

ir/shared/src/main/scala/org/scalajs/ir/Names.scala

@@ -501,6 +501,10 @@ object Names {
   val ArrayIndexOutOfBoundsExceptionClass: ClassName =
     ClassName("java.lang.ArrayIndexOutOfBoundsException")
 
+  /** The exception thrown by a `BinaryOp.String_charAt` that is out of bounds. */
+  val StringIndexOutOfBoundsExceptionClass: ClassName =
+    ClassName("java.lang.StringIndexOutOfBoundsException")
+
   /** The exception thrown by an `AsInstanceOf` that fails. */
   val ClassCastExceptionClass: ClassName =
     ClassName("java.lang.ClassCastException")

ir/shared/src/main/scala/org/scalajs/ir/Printers.scala

@@ -411,6 +411,12 @@ object Printers {
           print(rhs)
           print(')')
 
+        case BinaryOp(BinaryOp.String_charAt, lhs, rhs) =>
+          print(lhs)
+          print('[')
+          print(rhs)
+          print(']')
+
         case BinaryOp(op, lhs, rhs) =>
           import BinaryOp._
           print('(')

ir/shared/src/main/scala/org/scalajs/ir/Trees.scala

@@ -420,6 +420,9 @@ object Trees {
     final val Double_>  = 56
     final val Double_>= = 57
 
+    // New in 1.11
+    final val String_charAt = 58
+
     def resultTypeOf(op: Code): Type = (op: @switch) match {
       case === | !== |
           Boolean_== | Boolean_!= | Boolean_| | Boolean_& |
@@ -439,6 +442,8 @@ object Trees {
         FloatType
       case Double_+ | Double_- | Double_* | Double_/ | Double_% =>
         DoubleType
+      case String_charAt =>
+        CharType
     }
   }
 

ir/shared/src/test/scala/org/scalajs/ir/PrintersTest.scala

@@ -538,6 +538,9 @@ class PrintersTest {
         BinaryOp(Double_>, ref("x", DoubleType), ref("y", DoubleType)))
     assertPrintEquals("(x >=[double] y)",
         BinaryOp(Double_>=, ref("x", DoubleType), ref("y", DoubleType)))
+
+    assertPrintEquals("x[y]",
+        BinaryOp(String_charAt, ref("x", StringType), ref("y", IntType)))
   }
 
   @Test def printNewArray(): Unit = {

javalib/src/main/scala/java/lang/_String.scala

@@ -48,10 +48,11 @@ final class _String private () // scalastyle:ignore
 
   @inline
   def charAt(index: Int): Char =
-    this.asInstanceOf[js.Dynamic].charCodeAt(index).asInstanceOf[Int].toChar
+    throw new Error("stub") // body replaced by the compiler back-end
 
   def codePointAt(index: Int): Int = {
     if (linkingInfo.esVersion >= ESVersion.ES2015) {
+      charAt(index) // bounds check
       this.asInstanceOf[js.Dynamic].codePointAt(index).asInstanceOf[Int]
     } else {
       val high = charAt(index)
@@ -372,12 +373,26 @@ final class _String private () // scalastyle:ignore
     substring(beginIndex, endIndex)
 
   @inline
-  def substring(beginIndex: Int): String =
+  def substring(beginIndex: Int): String = {
+    // Bounds check (cleverly not using length() yet reporting errors in the appropriate cases)
+    if (beginIndex != 0)
+      charAt(beginIndex - 1)
+
     thisString.jsSubstring(beginIndex)
+  }
 
   @inline
-  def substring(beginIndex: Int, endIndex: Int): String =
+  def substring(beginIndex: Int, endIndex: Int): String = {
+    // Bounds check (cleverly not using length() yet reporting errors in the appropriate cases)
+    if (beginIndex != 0)
+      charAt(beginIndex - 1)
+    if (endIndex != 0)
+      charAt(endIndex - 1)
+    if (endIndex < beginIndex)
+      charAt(-1)
+
     thisString.jsSubstring(beginIndex, endIndex)
+  }
 
   def toCharArray(): Array[Char] = {
     val len = length()

linker-interface/shared/src/main/scala/org/scalajs/linker/interface/Semantics.scala

@@ -18,6 +18,7 @@ import Fingerprint.FingerprintBuilder
 final class Semantics private (
     val asInstanceOfs: CheckedBehavior,
     val arrayIndexOutOfBounds: CheckedBehavior,
+    val stringIndexOutOfBounds: CheckedBehavior,
     val moduleInit: CheckedBehavior,
     val strictFloats: Boolean,
     val productionMode: Boolean,
@@ -31,6 +32,9 @@ final class Semantics private (
   def withArrayIndexOutOfBounds(behavior: CheckedBehavior): Semantics =
     copy(arrayIndexOutOfBounds = behavior)
 
+  def withStringIndexOutOfBounds(behavior: CheckedBehavior): Semantics =
+    copy(stringIndexOutOfBounds = behavior)
+
   def withModuleInit(moduleInit: CheckedBehavior): Semantics =
     copy(moduleInit = moduleInit)
 
@@ -53,6 +57,7 @@ final class Semantics private (
   def optimized: Semantics = {
     copy(asInstanceOfs = this.asInstanceOfs.optimized,
         arrayIndexOutOfBounds = this.arrayIndexOutOfBounds.optimized,
+        stringIndexOutOfBounds = this.stringIndexOutOfBounds.optimized,
         moduleInit = this.moduleInit.optimized,
         productionMode = true)
   }
@@ -61,6 +66,7 @@ final class Semantics private (
     case that: Semantics =>
       this.asInstanceOfs == that.asInstanceOfs &&
       this.arrayIndexOutOfBounds == that.arrayIndexOutOfBounds &&
+      this.stringIndexOutOfBounds == that.stringIndexOutOfBounds &&
       this.moduleInit == that.moduleInit &&
       this.strictFloats == that.strictFloats &&
       this.productionMode == that.productionMode &&
@@ -74,26 +80,29 @@ final class Semantics private (
     var acc = HashSeed
     acc = mix(acc, asInstanceOfs.##)
     acc = mix(acc, arrayIndexOutOfBounds.##)
+    acc = mix(acc, stringIndexOutOfBounds.##)
     acc = mix(acc, moduleInit.##)
     acc = mix(acc, strictFloats.##)
     acc = mix(acc, productionMode.##)
     acc = mixLast(acc, runtimeClassNameMapper.##)
-    finalizeHash(acc, 6)
+    finalizeHash(acc, 7)
   }
 
   override def toString(): String = {
     s"""Semantics(
-       |  asInstanceOfs         = $asInstanceOfs,
-       |  arrayIndexOutOfBounds = $arrayIndexOutOfBounds,
-       |  moduleInit            = $moduleInit,
-       |  strictFloats          = $strictFloats,
-       |  productionMode        = $productionMode
+       |  asInstanceOfs          = $asInstanceOfs,
+       |  arrayIndexOutOfBounds  = $arrayIndexOutOfBounds,
+       |  stringIndexOutOfBounds = $stringIndexOutOfBounds,
+       |  moduleInit             = $moduleInit,
+       |  strictFloats           = $strictFloats,
+       |  productionMode         = $productionMode
        |)""".stripMargin
   }
 
   private def copy(
       asInstanceOfs: CheckedBehavior = this.asInstanceOfs,
       arrayIndexOutOfBounds: CheckedBehavior = this.arrayIndexOutOfBounds,
+      stringIndexOutOfBounds: CheckedBehavior = this.stringIndexOutOfBounds,
       moduleInit: CheckedBehavior = this.moduleInit,
       strictFloats: Boolean = this.strictFloats,
       productionMode: Boolean = this.productionMode,
@@ -102,6 +111,7 @@ final class Semantics private (
     new Semantics(
         asInstanceOfs = asInstanceOfs,
         arrayIndexOutOfBounds = arrayIndexOutOfBounds,
+        stringIndexOutOfBounds = stringIndexOutOfBounds,
         moduleInit = moduleInit,
         strictFloats = strictFloats,
         productionMode = productionMode,
@@ -217,6 +227,7 @@ object Semantics {
       new FingerprintBuilder("Semantics")
         .addField("asInstanceOfs", semantics.asInstanceOfs)
         .addField("arrayIndexOutOfBounds", semantics.arrayIndexOutOfBounds)
+        .addField("stringIndexOutOfBounds", semantics.stringIndexOutOfBounds)
         .addField("moduleInit", semantics.moduleInit)
         .addField("strictFloats", semantics.strictFloats)
         .addField("productionMode", semantics.productionMode)
@@ -228,6 +239,7 @@ object Semantics {
   val Defaults: Semantics = new Semantics(
       asInstanceOfs = Fatal,
       arrayIndexOutOfBounds = Fatal,
+      stringIndexOutOfBounds = Fatal,
       moduleInit = Unchecked,
       strictFloats = true,
       productionMode = false,

linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/CoreJSLib.scala

@@ -892,6 +892,22 @@ private[emitter] object CoreJSLib {
           Return(If(x > 2147483647, 2147483647, If(x < -2147483648, -2147483648, x | 0)))
         },
 
+        condTree(semantics.stringIndexOutOfBounds != CheckedBehavior.Unchecked)(
+          defineFunction2("charAt") { (s, i) =>
+            val r = varRef("r")
+
+            val throwStringIndexOutOfBoundsException = {
+              Throw(maybeWrapInUBE(semantics.stringIndexOutOfBounds,
+                  genScalaClassNew(StringIndexOutOfBoundsExceptionClass, IntArgConstructorName, i)))
+            }
+
+            Block(
+              const(r, Apply(genIdentBracketSelect(s, "charCodeAt"), List(i))),
+              If(r !== r, throwStringIndexOutOfBoundsException, Return(r))
+            )
+          }
+        ),
+
         condTree(allowBigIntsForLongs)(Block(
           defineFunction2("longDiv") { (x, y) =>
             If(y === bigInt(0), throwDivByZero, {

linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/Emitter.scala

@@ -828,7 +828,12 @@ object Emitter {
               StringArgConstructorName)
         },
 
-        cond(asInstanceOfs == Fatal || arrayIndexOutOfBounds == Fatal) {
+        cond(stringIndexOutOfBounds != Unchecked) {
+          instantiateClass(StringIndexOutOfBoundsExceptionClass,
+              IntArgConstructorName)
+        },
+
+        cond(asInstanceOfs == Fatal || arrayIndexOutOfBounds == Fatal || stringIndexOutOfBounds == Fatal) {
           instantiateClass(UndefinedBehaviorErrorClass,
               ThrowableArgConsructorName)
         },

linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/EmitterNames.scala

@@ -31,6 +31,7 @@ private[emitter] object EmitterNames {
   // Method names
 
   val AnyArgConstructorName = MethodName.constructor(List(ClassRef(ObjectClass)))
+  val IntArgConstructorName = MethodName.constructor(List(IntRef))
   val StringArgConstructorName = MethodName.constructor(List(ClassRef(BoxedStringClass)))
   val ThrowableArgConsructorName = MethodName.constructor(List(ClassRef(ThrowableClass)))
 

linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/FunctionEmitter.scala

@@ -1271,6 +1271,10 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
             case _                         => false
           }
 
+        // String_charAt preserves pureness iff the semantics for stringIndexOutOfBounds are unchecked
+        case BinaryOp(BinaryOp.String_charAt, lhs, rhs) =>
+          (allowSideEffects || semantics.stringIndexOutOfBounds == Unchecked) && test(lhs) && test(rhs)
+
         // Expressions preserving pureness
         case Block(trees)            => trees forall test
         case If(cond, thenp, elsep)  => test(cond) && test(thenp) && test(elsep)
@@ -2621,6 +2625,14 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
 
             case Boolean_| => !(!js.BinaryOp(JSBinaryOp.|, newLhs, newRhs))
             case Boolean_& => !(!js.BinaryOp(JSBinaryOp.&, newLhs, newRhs))
+
+            case String_charAt =>
+              semantics.stringIndexOutOfBounds match {
+                case CheckedBehavior.Compliant | CheckedBehavior.Fatal =>
+                  genCallHelper("charAt", newLhs, newRhs)
+                case CheckedBehavior.Unchecked =>
+                  js.Apply(genIdentBracketSelect(newLhs, "charCodeAt"), List(newRhs))
+              }
           }
 
         case NewArray(typeRef, lengths) =>

linker/shared/src/main/scala/org/scalajs/linker/checker/IRChecker.scala

@@ -513,10 +513,12 @@ private final class IRChecker(unit: LinkingUnit, reporter: ErrorReporter) {
               Double_== | Double_!= |
               Double_< | Double_<= | Double_> | Double_>= =>
             DoubleType
+          case String_charAt =>
+            StringType
         }
         val expectedRhsType = (op: @switch) match {
-          case Long_<< | Long_>>> | Long_>> => IntType
-          case _                            => expectedLhsType
+          case Long_<< | Long_>>> | Long_>> | String_charAt => IntType
+          case _                                            => expectedLhsType
         }
         typecheckExpect(lhs, env, expectedLhsType)
         typecheckExpect(rhs, env, expectedRhsType)