Use nullLiteral utility method

Author: odersky

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

@@ -57,6 +57,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def unitLiteral(implicit ctx: Context): Literal =
     Literal(Constant(()))
 
+  def nullLiteral(implicit ctx: Context): Literal =
+    Literal(Constant(null))
+
   def New(tpt: Tree)(implicit ctx: Context): New =
     ta.assignType(untpd.New(tpt), tpt)
 
@@ -496,7 +499,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     else if (tpw isRef defn.DoubleClass) Literal(Constant(0d))
     else if (tpw isRef defn.ByteClass) Literal(Constant(0.toByte))
     else if (tpw isRef defn.ShortClass) Literal(Constant(0.toShort))
-    else Literal(Constant(null)).select(defn.Any_asInstanceOf).appliedToType(tpe)
+    else nullLiteral.select(defn.Any_asInstanceOf).appliedToType(tpe)
   }
 
   private class FindLocalDummyAccumulator(cls: ClassSymbol)(implicit ctx: Context) extends TreeAccumulator[Symbol] {
@@ -915,7 +918,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         Typed(tree, TypeTree(defn.AnyRefType))
       }
       else tree.ensureConforms(defn.ObjectType)
-      receiver.select(defn.Object_ne).appliedTo(Literal(Constant(null)))
+      receiver.select(defn.Object_ne).appliedTo(nullLiteral)
     }
 
     /** If inititializer tree is `_', the default value of its type,

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

@@ -235,7 +235,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
           else {
             // insert test: if ($outer eq null) throw new NullPointerException
             val nullTest =
-              If(ref(param).select(defn.Object_eq).appliedTo(Literal(Constant(null))),
+              If(ref(param).select(defn.Object_eq).appliedTo(nullLiteral),
                  Throw(New(defn.NullPointerExceptionClass.typeRef, Nil)),
                  unitLiteral)
             nullTest :: assigns

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

@@ -218,7 +218,7 @@ object Erasure {
               adaptToType(tree, underlying)
             else if (!(tree.tpe <:< tycon)) {
               assert(!(tree.tpe.typeSymbol.isPrimitiveValueClass))
-              val nullTree = Literal(Constant(null))
+              val nullTree = nullLiteral
               val unboxedNull = adaptToType(nullTree, underlying)
 
               evalOnce(tree) { t =>

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

@@ -189,14 +189,12 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     holders:::stats
   }
 
-  private def nullOut(nullables: List[Symbol])(implicit ctx: Context): List[Tree] = {
-    val nullConst = Literal(Constant(null))
+  private def nullOut(nullables: List[Symbol])(implicit ctx: Context): List[Tree] =
     nullables.map { field =>
       assert(field.isField)
       field.setFlag(Mutable)
-      ref(field).becomes(nullConst)
+      ref(field).becomes(nullLiteral)
     }
-  }
 
   /** Create non-threadsafe lazy accessor equivalent to such code
     * ```
@@ -237,7 +235,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     val targetRef = ref(target)
     val stats = targetRef.becomes(rhs) :: nullOut(nullableFor(sym))
     val init = If(
-      targetRef.select(nme.eq).appliedTo(Literal(Constant(null))),
+      targetRef.select(nme.eq).appliedTo(nullLiteral),
       Block(stats.init, stats.last),
       unitLiteral
     )

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

@@ -106,8 +106,8 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
     val NoFieldNeeded = Lazy | Deferred | JavaDefined | (if (ctx.settings.YnoInline.value) EmptyFlags else Inline)
 
     def erasedBottomTree(sym: Symbol) = {
-      if (sym eq defn.NothingClass) Throw(Literal(Constant(null)))
-      else if (sym eq defn.NullClass) Literal(Constant(null))
+      if (sym eq defn.NothingClass) Throw(nullLiteral)
+      else if (sym eq defn.NullClass) nullLiteral
       else if (sym eq defn.BoxedUnitClass) ref(defn.BoxedUnit_UNIT)
       else {
         assert(false, sym + " has no erased bottom tree")

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

@@ -361,7 +361,7 @@ object PatternMatcher {
           val unappPlan = if (defn.isBottomType(scrutinee.info)) {
             // Generate a throwaway but type-correct plan.
             // This plan will never execute because it'll be guarded by a `NonNullTest`.
-            ResultPlan(tpd.Throw(tpd.Literal(Constant(null))))
+            ResultPlan(tpd.Throw(tpd.nullLiteral))
           } else {
             val mt @ MethodType(_) = extractor.tpe.widen
             var unapp = extractor.appliedTo(ref(scrutinee).ensureConforms(mt.paramInfos.head))