Rename to isNothing

Author: noti0na1

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -586,7 +586,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           val tree2: Select = tree.tpe match {
             case tpe: NamedType =>
               val qualType = qualifier.tpe.widenIfUnstable
-              if qualType.isNothingType then tree1.withTypeUnchecked(tree.tpe)
+              if qualType.isNothing then tree1.withTypeUnchecked(tree.tpe)
               else tree1.withType(tpe.derivedSelect(qualType))
             case _ => tree1.withTypeUnchecked(tree.tpe)
           }

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

@@ -2325,7 +2325,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    */
   def provablyEmpty(tp: Type): Boolean =
     tp.dealias match {
-      case tp if tp.isNothingType => true
+      case tp if tp.isNothing => true
       case AndType(tp1, tp2) => provablyDisjoint(tp1, tp2)
       case OrType(tp1, tp2) => provablyEmpty(tp1) && provablyEmpty(tp2)
       case at @ AppliedType(tycon, args) =>

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

@@ -266,7 +266,7 @@ object Types {
       }
 
     /** Is this type exactly Nothing (no vars, aliases, refinements etc allowed)? */
-    def isNothingType(using Context): Boolean = this match {
+    def isNothing(using Context): Boolean = this match {
       case tp: TypeRef =>
         tp.name == tpnme.Nothing && (tp.symbol eq defn.NothingClass)
       case _ => false
@@ -2126,7 +2126,7 @@ object Types {
           case arg: TypeBounds =>
             val v = param.paramVarianceSign
             val pbounds = param.paramInfo
-            if (v > 0 && pbounds.loBound.dealiasKeepAnnots.isNothingType) TypeAlias(arg.hiBound & rebase(pbounds.hiBound))
+            if (v > 0 && pbounds.loBound.dealiasKeepAnnots.isNothing) TypeAlias(arg.hiBound & rebase(pbounds.hiBound))
             else if (v < 0 && pbounds.hiBound.dealiasKeepAnnots.isTopType) TypeAlias(arg.loBound | rebase(pbounds.loBound))
             else arg recoverable_& rebase(pbounds)
           case arg => TypeAlias(arg)
@@ -2289,7 +2289,7 @@ object Types {
           if (base.isAnd == variance >= 0) tp1 & tp2 else tp1 | tp2
         case _ =>
           if (pre.termSymbol.is(Package)) argForParam(pre.select(nme.PACKAGE))
-          else if (pre.isNothingType) pre
+          else if (pre.isNothing) pre
           else NoType
       }
     }
@@ -2308,7 +2308,7 @@ object Types {
      */
     def derivedSelect(prefix: Type)(using Context): Type =
       if (prefix eq this.prefix) this
-      else if (prefix.isNothingType) prefix
+      else if (prefix.isNothing) prefix
       else {
         if (isType) {
           val res =
@@ -4292,7 +4292,7 @@ object Types {
 
     /** For uninstantiated type variables: Is the lower bound different from Nothing? */
     def hasLowerBound(using Context): Boolean =
-      !ctx.typerState.constraint.entry(origin).loBound.isNothingType
+      !ctx.typerState.constraint.entry(origin).loBound.isNothing
 
     /** For uninstantiated type variables: Is the upper bound different from Any? */
     def hasUpperBound(using Context): Boolean =
@@ -5297,7 +5297,7 @@ object Types {
         case _ =>
           def propagate(lo: Type, hi: Type) =
             range(derivedRefinedType(tp, parent, lo), derivedRefinedType(tp, parent, hi))
-          if (parent.isNothingType) parent
+          if (parent.isNothing) parent
           else info match {
             case Range(infoLo: TypeBounds, infoHi: TypeBounds) =>
               assert(variance == 0)
@@ -5390,7 +5390,7 @@ object Types {
         case Range(lo, hi) =>
           range(tp.derivedAnnotatedType(lo, annot), tp.derivedAnnotatedType(hi, annot))
         case _ =>
-          if (underlying.isNothingType) underlying
+          if (underlying.isNothing) underlying
           else tp.derivedAnnotatedType(underlying, annot)
       }
     override protected def derivedWildcardType(tp: WildcardType, bounds: Type): WildcardType =
@@ -5638,7 +5638,7 @@ object Types {
       else {
         seen += tp
         tp match {
-          case tp if tp.isTopType || tp.isNothingType =>
+          case tp if tp.isTopType || tp.isNothing =>
             cs
           case tp: AppliedType =>
             foldOver(cs + tp.typeSymbol, tp)

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -205,7 +205,7 @@ object Completion {
      * considered.
      */
     def addMemberCompletions(qual: Tree)(using Context): Unit =
-      if (!qual.tpe.widenDealias.isNothingType) {
+      if (!qual.tpe.widenDealias.isNothing) {
         addAccessibleMembers(qual.tpe)
         if (!mode.is(Mode.Import) && !qual.tpe.isNullType)
           // Implicit conversions do not kick in when importing

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

@@ -169,7 +169,7 @@ object ErrorReporting {
            |Note that `${tree.name}` is treated as an infix operator in Scala 3.
            |If you do not want that, insert a `;` or empty line in front
            |or drop any spaces behind the operator."""
-      else if qualType.isNothingType then
+      else if qualType.isNothing then
         ""
       else
         val add = suggestImports(