Address review comments

syntheticCoreClasses and syntheticScalaClasses should be memoized (lazy
val instead of def).

Don't use braces when testing for explicit nulls flag.

Author: abeln

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

@@ -305,16 +305,8 @@ class Definitions {
   def AnyRefType: TypeRef = AnyRefAlias.typeRef
 
     // TODO(abeln): modify usage sites to use `RefEq_eq/ne` once we migrate to explicit nulls?
-    lazy val Object_eq: TermSymbol = if (ctx.explicitNulls) {
-      RefEq_eq
-    } else {
-      enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
-    }
-    lazy val Object_ne: TermSymbol = if (ctx.explicitNulls) {
-      RefEq_ne
-    } else {
-      enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
-    }
+    lazy val Object_eq: TermSymbol = if (ctx.explicitNulls) RefEq_eq else enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
+    lazy val Object_ne: TermSymbol = if (ctx.explicitNulls) RefEq_ne else enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
     lazy val Object_synchronized: TermSymbol = enterPolyMethod(ObjectClass, nme.synchronized_, 1,
         pt => MethodType(List(pt.paramRefs(0)), pt.paramRefs(0)), Final)
     lazy val Object_clone: TermSymbol = enterMethod(ObjectClass, nme.clone_, MethodType(Nil, ObjectType), Protected)
@@ -349,11 +341,7 @@ class Definitions {
 
   /** Method representing a throw */
   lazy val throwMethod: TermSymbol = {
-    val argTpe = if (ctx.explicitNulls) {
-      OrType(ThrowableType, NullType)
-    } else {
-      ThrowableType
-    }
+    val argTpe = if (ctx.explicitNulls) OrType(ThrowableType, NullType) else ThrowableType
     enterMethod(OpsPackageClass, nme.THROWkw, MethodType(List(argTpe), NothingType))
   }
 
@@ -362,7 +350,7 @@ class Definitions {
   def NothingType: TypeRef = NothingClass.typeRef
   lazy val RuntimeNothingModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.Nothing")
 
-  /** `RefEq` is the trait defining the reference equality operators (`eq`, `neq`).
+  /** `RefEq` is the trait defining the reference equality operators (`eq`, `ne`).
    *  It's a supertype of both `AnyRef` (which is non-nullable) and `Null`.
    *  With `RefEq`, we can compare `null` for reference equality a la `null eq foo`.
    *  `RefEq` is just a marker trait and there's no corresponding class file, since it gets erased to `Object`.
@@ -391,11 +379,7 @@ class Definitions {
     }
 
   lazy val NullClass: ClassSymbol = {
-    val parents = if (ctx.explicitNulls) {
-      List(AnyType, RefEqType)
-    } else {
-      List(ObjectType)
-    }
+    val parents = if (ctx.explicitNulls) List(AnyType, RefEqType) else List(ObjectType)
     enterCompleteClassSymbol(ScalaPackageClass, tpnme.Null, AbstractFinal, parents)
   }
   def NullType: TypeRef = NullClass.typeRef
@@ -1250,11 +1234,7 @@ class Definitions {
 
   lazy val NotRuntimeClasses: Set[Symbol] = {
     val classes: Set[Symbol] = Set(AnyClass, AnyValClass, NullClass, NothingClass)
-    if (ctx.explicitNulls) {
-      classes + RefEqClass
-    } else {
-      classes
-    }
+    if (ctx.explicitNulls) classes + RefEqClass else classes
   }
 
   /** Classes that are known not to have an initializer irrespective of
@@ -1468,7 +1448,7 @@ class Definitions {
   // ----- Initialization ---------------------------------------------------
 
   /** Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
-  def syntheticScalaClasses(implicit ctx: Context): List[TypeSymbol] = {
+  lazy val syntheticScalaClasses: List[TypeSymbol] = {
     val synth = List(
       AnyClass,
       AnyRefAlias,
@@ -1487,18 +1467,14 @@ class Definitions {
     else synth
   }
 
-  def syntheticCoreClasses(implicit ctx: Context): List[Symbol] = syntheticScalaClasses ++ List(
+  lazy val syntheticCoreClasses: List[Symbol] = syntheticScalaClasses ++ List(
     EmptyPackageVal,
     OpsPackageClass)
 
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
   lazy val syntheticCoreMethods: List[TermSymbol] = {
     val methods = AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
-    if (ctx.explicitNulls) {
-      methods ++ RefEqMethods
-    } else {
-      methods
-    }
+    if (ctx.explicitNulls) methods ++ RefEqMethods else methods
   }
 
   lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
@@ -1513,7 +1489,7 @@ class Definitions {
         ScalaPackageClass.enter(m)
 
       // force initialization of every symbol that is synthesized or hijacked by the compiler
-      val forced = syntheticCoreClasses(ctx) ++ syntheticCoreMethods ++ ScalaValueClasses()
+      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses()
 
       isInitialized = true
     }