Add special case to init checker to always allow certain methods

Closes #14275 - Treats mehtods `ne`, `eq`, `isInstanceOf`, and `asInstanceOf` as safe to call, regardless of initialization Signed the CLA - @Xavientois Review by @liufengyun

Author: Xavientois

compiler/src/dotty/tools/dotc/transform/init/Semantic.scala

@@ -596,8 +596,15 @@ object Semantic {
  && meth.owner.is(Flags.Module)
  && meth.owner.companionClass.is(Flags.Case)
 
+ def isAlwaysSafe(meth: Symbol) =
+ (meth eq defn.Object_eq)
+ || (meth eq defn.Object_ne)
+ || (meth eq defn.Any_isInstanceOf)
+
  // fast track if the current object is already initialized
  if promoted.isCurrentObjectPromoted then Result(Hot, Nil)
+ else if isAlwaysSafe(meth) then Result(Hot, Nil)
+ else if meth eq defn.Any_asInstanceOf then Result(value, Nil)
  else value match {
  case Hot =>
  if isSyntheticApply(meth) then

tests/init/neg/as-instance-of-cold-field-access.scala

@@ -0,0 +1,7 @@
+final class MyAsInstanceOfClass(o: MyAsInstanceOfClass) {
+ val other: MyAsInstanceOfClass = {
+ if (o.asInstanceOf[MyAsInstanceOfClass].oRef ne null) o // error
+ else new MyAsInstanceOfClass(this)
+ }
+ val oRef = o
+}

tests/init/pos/eq-ne-always-valid.scala

@@ -0,0 +1,13 @@
+final class MyNeClass(o: MyNeClass) {
+ val other: MyNeClass = {
+ if (o ne null) o // o is cold, but ne is always valid
+ else new MyNeClass(this)
+ }
+}
+
+final class MyEqClass(o: MyEqClass) {
+ val other: MyEqClass = {
+ if (o eq null) new MyEqClass(this) // o is cold, but eq is always valid
+ else o
+ }
+}

tests/init/pos/instance-of-always-valid.scala

@@ -0,0 +1,22 @@
+final class MyIsInstanceOfClass(o: MyIsInstanceOfClass) {
+ val other: MyIsInstanceOfClass = {
+ if (!o.isInstanceOf[Object]) new MyIsInstanceOfClass(this) // o is cold, but isInstanceOf is always valid
+ else o
+ }
+}
+
+final class MyAsInstanceOfClass(o: MyAsInstanceOfClass) {
+ val other: MyAsInstanceOfClass = {
+ if (o.asInstanceOf[Object] ne null) o // o is cold, but ne and AsInstanceOf is always valid
+ else new MyAsInstanceOfClass(this)
+ }
+}
+
+final class MyAsInstanceOfFieldClass(o: MyAsInstanceOfFieldClass) {
+ val oRef = o
+ val other: MyAsInstanceOfFieldClass = {
+ if (this.asInstanceOf[MyAsInstanceOfFieldClass].oRef ne null) oRef // o is cold, but ne and AsInstanceOf is always valid
+ else new MyAsInstanceOfFieldClass(this)
+ }
+}
+