warn about unnecessary uses of .nn

Author: olhotak

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

@@ -50,6 +50,18 @@ object NullOpsDecorator:
       val stripped = self.stripNull()
       stripped ne self
     }
+
+    def admitsNull(using Context): Boolean = {
+      val widened = self.widenDealias
+      widened.isNullType || widened.isAny || (widened match
+        case OrType(l, r) => r.admitsNull || l.admitsNull
+        case AndType(l, r) => r.admitsNull && l.admitsNull
+        case TypeBounds(lo, hi) => lo.admitsNull
+        case FlexibleType(lo, hi) => true
+        case tp: TypeProxy => tp.underlying.admitsNull
+        case _ => false
+      )
+    }
   end extension
 
   import ast.tpd.*

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

@@ -564,6 +564,7 @@ object StdNames {
     val next: N                 = "next"
     val nmeNewTermName: N       = "newTermName"
     val nmeNewTypeName: N       = "newTypeName"
+    val nn: N                   = "nn"
     val noAutoTupling: N        = "noAutoTupling"
     val normalize: N            = "normalize"
     val notifyAll_ : N          = "notifyAll"

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

@@ -373,7 +373,7 @@ object Types extends TypeUtils {
     final def isNotNull(using Context): Boolean = this match {
       case tp: ConstantType => tp.value.value != null
       case tp: FlexibleType => false
-      case tp: ClassInfo => !tp.cls.isNullableClass && tp.cls != defn.NothingClass
+      case tp: ClassInfo => !tp.cls.isNullableClass && !tp.isNothingType
       case tp: AppliedType => tp.superType.isNotNull
       case tp: TypeBounds => tp.lo.isNotNull
       case tp: TypeProxy => tp.underlying.isNotNull

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

@@ -1088,7 +1088,19 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         errorTree(tree, em"cannot convert to type selection") // will never be printed due to fallback
     }
 
-    if (tree.qualifier.isType) {
+    def warnUnnecessaryNN(tree: Tree): Unit = {
+      if ctx.explicitNulls then {
+        val symbol = tree.symbol
+        if symbol.exists && symbol.owner == defn.ScalaPredefModuleClass && symbol.name == nme.nn then
+          tree match
+          case Apply(_, args) =>
+            if(args.head.tpe.isNotNull) then report.warning("Unnecessary .nn: qualifier is already not null", tree)
+            if pt.admitsNull then report.warning("Unnecessary .nn: expected type admits null", tree)
+          case _ =>
+      }
+    }
+
+    val tree1 = if (tree.qualifier.isType) {
       val qual1 = typedType(tree.qualifier, shallowSelectionProto(tree.name, pt, this, tree.nameSpan))
       assignType(cpy.Select(tree)(qual1, tree.name), qual1)
     }
@@ -1098,6 +1110,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       tryAlternatively(typeSelectOnTerm)(tryJavaSelectOnType)
     else
       typeSelectOnTerm
+
+    warnUnnecessaryNN(tree1)
+    tree1
   }
 
   def typedThis(tree: untpd.This)(using Context): Tree = {

tests/explicit-nulls/warn/unnecessary-nn.scala

@@ -0,0 +1,13 @@
+def f1(s: String): String = s.nn // warn
+def f2(s: String|Null): String|Null = s.nn // warn
+def f3(s: String|Null): Any = s.nn // warn
+def f4(s: String|Null): String = s.nn
+
+def f5[T >: String](s: String|Null): T = s.nn
+def f6[T >: String|Null](s: String|Null): T = s.nn // warn
+
+def f5a[T <: String](s: T): String = s.nn // warn
+
+// flexible types
+def f7(s: String|Null) = "".concat(s.nn) // warn
+def f8(s: String): String = s.trim().nn // OK because the .nn could be useful as a dynamic null check