Fix checkImplicitUse

Author: noti0na1

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

@@ -456,7 +456,7 @@ class Definitions {
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
   def NothingType: TypeRef = NothingClass.typeRef
   @tu lazy val NullClass: ClassSymbol = {
-    val parent = if (ctx.explicitNulls) AnyType else ObjectType
+    val parent = if ctx.explicitNulls then AnyType else ObjectType
     enterCompleteClassSymbol(ScalaPackageClass, tpnme.Null, AbstractFinal, parent :: Nil)
   }
   def NullType: TypeRef = NullClass.typeRef
@@ -640,14 +640,14 @@ class Definitions {
   @tu lazy val ClassCastExceptionClass: ClassSymbol   = requiredClass("java.lang.ClassCastException")
     @tu lazy val ClassCastExceptionClass_stringConstructor: TermSymbol  = ClassCastExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
       case List(pt) =>
-        val pt1 = if (ctx.explicitNulls) pt.stripNull else pt
+        val pt1 = if ctx.explicitNulls then pt.stripNull else pt
         pt1.isRef(StringClass)
       case _ => false
     }).symbol.asTerm
   @tu lazy val ArithmeticExceptionClass: ClassSymbol  = requiredClass("java.lang.ArithmeticException")
     @tu lazy val ArithmeticExceptionClass_stringConstructor: TermSymbol  = ArithmeticExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
       case List(pt) =>
-        val pt1 = if (ctx.explicitNulls) pt.stripNull else pt
+        val pt1 = if ctx.explicitNulls then pt.stripNull else pt
         pt1.isRef(StringClass)
       case _ => false
     }).symbol.asTerm
@@ -1163,13 +1163,13 @@ class Definitions {
     idx == name.length || name(idx).isDigit && digitsOnlyAfter(name, idx + 1)
 
   def isBottomClass(cls: Symbol): Boolean =
-    if (ctx.explicitNulls && !ctx.phase.erasedTypes) cls == NothingClass
+    if ctx.explicitNulls && !ctx.phase.erasedTypes then cls == NothingClass
     else isBottomClassAfterErasure(cls)
 
   def isBottomClassAfterErasure(cls: Symbol): Boolean = cls == NothingClass || cls == NullClass
 
   def isBottomType(tp: Type): Boolean =
-    if (ctx.explicitNulls && !ctx.phase.erasedTypes) tp.derivesFrom(NothingClass)
+    if ctx.explicitNulls && !ctx.phase.erasedTypes then tp.derivesFrom(NothingClass)
     else isBottomTypeAfterErasure(tp)
 
   def isBottomTypeAfterErasure(tp: Type): Boolean =

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

@@ -58,10 +58,10 @@ object JavaNullInterop {
     assert(sym.is(JavaDefined), "can only nullify java-defined members")
 
     // Some special cases when nullifying the type
-    if (isEnumValueDef || sym.name == nme.TYPE_)
+    if isEnumValueDef || sym.name == nme.TYPE_ then
       // Don't nullify the `TYPE` field in every class and Java enum instances
       tp
-    else if (sym.name == nme.toString_ || sym.isConstructor || hasNotNullAnnot(sym))
+    else if sym.name == nme.toString_ || sym.isConstructor || hasNotNullAnnot(sym) then
       // Don't nullify the return type of the `toString` method.
       // Don't nullify the return type of constructors.
       // Don't nullify the return type of methods with a not-null annotation.
@@ -126,7 +126,7 @@ object JavaNullInterop {
         val targs2 = targs map this
         outermostLevelAlreadyNullable = oldOutermostNullable
         val appTp2 = derivedAppliedType(appTp, tycon, targs2)
-        if (needsNull(tycon)) OrNull(appTp2) else appTp2
+        if needsNull(tycon) then OrNull(appTp2) else appTp2
       case ptp: PolyType =>
         derivedLambdaType(ptp)(ptp.paramInfos, this(ptp.resType))
       case mtp: MethodType =>

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

@@ -72,13 +72,17 @@ object NullOpsDecorator {
     def isUnsafelyNulltoAnyRef(pt: Type)(using Context): Boolean =
       self.isNullType && pt.isNullableAfterErasure
 
+    def isUnsafeSubtype(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
+      val selfs = self.stripAllNulls
+      val pts = pt.stripAllNulls
+      if relaxedSubtype then
+        selfs relaxed_<:< pts
+      else
+        selfs <:< pts
+
     /** Can we convert a tree with type `self` to type `pt` unsafely.
      */
     def isUnsafelyConvertable(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
-      self.isUnsafelyNulltoAnyRef(pt) ||
-      (if relaxedSubtype then
-        self.stripAllNulls relaxed_<:< pt.stripAllNulls
-      else
-        self.stripAllNulls <:< pt.stripAllNulls)
+      self.isUnsafelyNulltoAnyRef(pt) || self.isUnsafeSubtype(pt, relaxedSubtype)
   }
 }

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

@@ -515,13 +515,12 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
   }
 
   private def eraseArray(tp: Type)(using Context) = {
-    val defn.ArrayOf(elemtp) = tp
-    if (classify(elemtp).derivesFrom(defn.NullClass)) JavaArrayType(defn.ObjectType)
-    else {
-      val elemtp1 = if (ctx.explicitNulls) elemtp.stripNull else elemtp
-      if (isUnboundedGeneric(elemtp1) && !isJava) defn.ObjectType
-      else JavaArrayType(erasureFn(isJava, semiEraseVCs = false, isConstructor, wildcardOK)(elemtp1))
-    }
+    val defn.ArrayOf(elemtp0) = tp
+    val elemtp = if ctx.explicitNulls then elemtp0.stripNull else elemtp0
+    if classify(elemtp).derivesFrom(defn.NullClass) then JavaArrayType(defn.ObjectType)
+    else
+      if isUnboundedGeneric(elemtp) && !isJava then defn.ObjectType
+      else JavaArrayType(erasureFn(isJava, semiEraseVCs = false, isConstructor, wildcardOK)(elemtp))
   }
 
   private def erasePair(tp: Type)(using Context): Type = {

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -202,7 +202,8 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       // Second constructor of ioob that takes a String argument
       def filterStringConstructor(s: Symbol): Boolean = s.info match {
         case m: MethodType if s.isConstructor && m.paramInfos.size == 1 =>
-          val pinfo = if (ctx.explicitNulls) m.paramInfos.head.stripNull else m.paramInfos.head
+          val head = m.paramInfos.head
+          val pinfo = if ctx.explicitNulls then head.stripNull else head
           pinfo == defn.StringType
         case _ => false
       }

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

@@ -767,16 +767,20 @@ trait Checking {
    *  enabled.
    */
   def checkImplicitConversionUseOK(tree: Tree)(using Context): Unit =
-    val sym = tree.symbol
+    val tree1 = if ctx.mode.is(Mode.UnsafeNullConversion) then
+      // If unsafeNulls is enabled, a cast and a closure could be added to the original tree
+      stripCast(closureBody(tree))
+    else tree
+    val sym = tree1.symbol
     if sym.name == nme.apply
        && sym.owner.derivesFrom(defn.ConversionClass)
        && !sym.info.isErroneous
     then
-      def conv = methPart(tree) match
+      def conv = methPart(tree1) match
         case Select(qual, _) => qual.symbol.orElse(sym.owner)
         case _ => sym.owner
       checkFeature(nme.implicitConversions,
-        i"Use of implicit conversion ${conv.showLocated}", NoSymbol, tree.srcPos)
+        i"Use of implicit conversion ${conv.showLocated}", NoSymbol, tree1.srcPos)
 
   private def infixOKSinceFollowedBy(tree: untpd.Tree): Boolean = tree match {
     case _: untpd.Block | _: untpd.Match => true

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

@@ -133,7 +133,7 @@ object Implicits:
                   if (approx) formal = wildApprox(formal)
                   explore((argType relaxed_<:< formal.widenExpr) ||
                     Nullables.convertUnsafeNulls &&
-                      argType.isUnsafelyConvertable(formal.widenExpr))
+                      argType.isUnsafeSubtype(formal.widenExpr, true))
                 })
               Candidate.Conversion
             else

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

@@ -40,10 +40,8 @@ object ProtoTypes {
       val tpw = tp.widenExpr
       val ptw = pt.widenExpr
       (tpw relaxed_<:< ptw) ||
-        // If unsafeNulls is enabled, we relax the condition by striping all nulls from the types
-        // before subtype check. We use Feature to check language feature. However, when we search implicits,
-        // the context is from ContextualImplicits; hence, we don't know whether unsafeNulls is enabled.
-        // We have to add Mode.UnsafeNullConversion before implicit search.
+        // If unsafeNulls is enabled, we relax the condition by
+        // striping all nulls from the types before subtype check.
         Nullables.convertUnsafeNulls && tpw.isUnsafelyConvertable(ptw, true) ||
         viewExists(tp, pt)
 
@@ -55,9 +53,9 @@ object ProtoTypes {
       val ptw = pt.widenExpr
       necessarySubType(tpw, ptw) || tpw.isValueSubType(ptw) ||
       Nullables.convertUnsafeNulls && {
+        // See comments in `isCompatible`
         val tpwsn = tpw.stripAllNulls
         val ptwsn = ptw.stripAllNulls
-        // See comments in `isCompatible`
         necessarySubType(tpwsn, ptwsn) || tpwsn.isValueSubType(ptwsn) ||
           tpwsn.isUnsafelyNulltoAnyRef(ptwsn)
       } ||

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

@@ -556,18 +556,18 @@ class Typer extends Namer
 
     def typeSelectOnTerm(using Context): Tree =
       val qual = typedExpr(tree.qualifier, selectionProto(tree.name, pt, this))
-      val qual1 = qual.tpe match {
-        case OrNull(tpe1) if config.Feature.enabled(nme.unsafeNulls) =>
-          qual.cast(AndType(qual.tpe, tpe1))
-        case tp =>
-          if ctx.explicitNulls &&
-            tp.isNullType &&
-            config.Feature.enabled(nme.unsafeNulls) &&
-            (tree.name == nme.eq || tree.name == nme.ne) then
-            // Allow selecting `eq` and `ne` on `Null` specially
-            qual.cast(defn.ObjectType)
-          else qual
-      }
+      val qual1 = if Nullables.convertUnsafeNulls then
+        qual.tpe match {
+          case OrNull(tpe1) =>
+            qual.cast(AndType(qual.tpe, tpe1))
+          case tp =>
+            if tp.isNullType &&
+              (tree.name == nme.eq || tree.name == nme.ne) then
+              // Allow selecting `eq` and `ne` on `Null` specially
+              qual.cast(defn.ObjectType)
+            else qual
+        }
+      else qual
       typedSelect(tree, pt, qual1).computeNullable()
 
     def typeSelectOnType(qual: untpd.Tree)(using Context) =