add eq/ne extension for AnyRef|Null to Scala3RunTime

Author: olhotak

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -401,7 +401,7 @@ object Contexts {
     def isImportContext: Boolean =
       (this ne NoContext)
       && (outer ne NoContext)
-      && (this.importInfo nen outer.importInfo)
+      && (this.importInfo ne outer.importInfo)
 
     /** Is this a context that introduces a non-empty scope? */
     def isNonEmptyScopeContext: Boolean =

compiler/src/dotty/tools/dotc/core/TyperState.scala

@@ -254,7 +254,7 @@ class TyperState() {
       val toCollect = new mutable.ListBuffer[TypeLambda]
       for tvar <- ownedVars do
         val tvarState = tvar.owningState.nn.get
-        assert(tvarState eqn this, s"Inconsistent state in $this: it owns $tvar whose owningState is ${tvarState}")
+        assert(tvarState eq this, s"Inconsistent state in $this: it owns $tvar whose owningState is ${tvarState}")
         assert(!tvar.inst.exists, s"Inconsistent state in $this: it owns $tvar which is already instantiated")
         val inst = constraint.instType(tvar)
         if inst.exists then

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -322,7 +322,7 @@ object Implicits:
      */
     private def isOuterMost = {
       val finalImplicits = NoContext.implicits
-      (this eq finalImplicits) || (outerImplicits eqn finalImplicits)
+      (this eq finalImplicits) || (outerImplicits eq finalImplicits)
     }
 
     private def combineEligibles(ownEligible: List[Candidate], outerEligible: List[Candidate]): List[Candidate] =
@@ -383,7 +383,7 @@ object Implicits:
       else {
         val outerExcluded = outerImplicits.nn exclude root
         if (irefCtx.importInfo.nn.site.termSymbol == root) outerExcluded
-        else if (outerExcluded eqn outerImplicits) this
+        else if (outerExcluded eq outerImplicits) this
         else new ContextualImplicits(refs, outerExcluded, isImport)(irefCtx)
       }
   }

compiler/src/dotty/tools/dotc/typer/ImportInfo.scala

@@ -218,7 +218,7 @@ class ImportInfo(symf: Context ?=> Symbol,
           case Some(bv) => bv
           case None =>
             var c = ctx.outer
-            while c.importInfo eqn ctx.importInfo do c = c.outer
+            while c.importInfo eq ctx.importInfo do c = c.outer
             val cinfo = c.importInfo
             (cinfo != null) && cinfo.featureImported(feature)(using c)
       )

compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala

@@ -123,7 +123,7 @@ trait ImportSuggestions:
               .filter(lookInside(_))
               .flatMap(sym => rootsIn(sym.termRef))
         val imported =
-          if ctx.importInfo eqn ctx.outer.importInfo then Nil
+          if ctx.importInfo eq ctx.outer.importInfo then Nil
           else ctx.importInfo.nn.importSym.info match
             case ImportType(expr) => rootsOnPath(expr.tpe)
             case _ => Nil

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -434,7 +434,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               if (curImport.nn.unimported ne NoSymbol) unimported += curImport.nn.unimported
             if (curOwner.is(Package) && curImport != null && curImport.isRootImport && previous.exists)
               previous // no more conflicts possible in this case
-            else if (isPossibleImport(NamedImport) && (curImport nen outer.importInfo)) {
+            else if (isPossibleImport(NamedImport) && (curImport ne outer.importInfo)) {
               val namedImp = namedImportRef(curImport.uncheckedNN)
               if (namedImp.exists)
                 recurAndCheckNewOrShadowed(namedImp, NamedImport, ctx)(using outer)

compiler/src/dotty/tools/package.scala

@@ -36,13 +36,6 @@ package object tools {
       if x == null then None else Some(x.asInstanceOf[T])
   end extension
 
-  /** Nullable eq and ne. */
-  extension [T <: AnyRef](x: T | Null)
-    inline def eqn (y: T | Null) =
-      x.asInstanceOf[AnyRef] eq y.asInstanceOf[AnyRef]
-
-    inline def nen(y: T | Null): Boolean = !eqn(y)
-
   object resultWrapper {
     opaque type WrappedResult[T] = T
     private[tools] def unwrap[T](x: WrappedResult[T]): T = x

library/src/scala/runtime/Scala3RunTime.scala

@@ -19,4 +19,10 @@ object Scala3RunTime:
     if (isNull) throw new NullPointerException("tried to cast away nullability, but value is null")
     else x.asInstanceOf[x.type & T]
 
+  extension (inline x: AnyRef | Null)
+    inline def eq(inline y: AnyRef | Null): Boolean =
+      x.asInstanceOf[AnyRef] eq y.asInstanceOf[AnyRef]
+    inline def ne(inline y: AnyRef | Null): Boolean =
+      !(x eq y)
+
 end Scala3RunTime