Address reviewer feedback

* Use NoType instead of Option[Type]
* Move a Set to a val to avoid recomputing it on every call

Author: MaximeKjaer

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

@@ -234,6 +234,8 @@ class Definitions {
       @tu lazy val CompiletimeTesting_ErrorKind_Parser: Symbol = CompiletimeTesting_ErrorKind.requiredMethod("Parser")
       @tu lazy val CompiletimeTesting_ErrorKind_Typer: Symbol = CompiletimeTesting_ErrorKind.requiredMethod("Typer")
   @tu lazy val CompiletimeOpsPackageObject: Symbol = ctx.requiredModule("scala.compiletime.ops.package")
+    @tu lazy val CompiletimeOpsPackageObjectInt: Symbol = ctx.requiredModule("scala.compiletime.ops.package.int")
+    @tu lazy val CompiletimeOpsPackageObjectString: Symbol = ctx.requiredModule("scala.compiletime.ops.package.string")
 
   /** The `scalaShadowing` package is used to safely modify classes and
    *  objects in scala so that they can be used from dotty. They will
@@ -899,15 +901,17 @@ class Definitions {
   final def isCompiletime_S(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.name == tpnme.S && sym.owner == CompiletimePackageObject.moduleClass
 
+  private val compiletimePackageTypes: Set[Name] = Set(
+    tpnme.Equals, tpnme.NotEquals,
+    tpnme.Plus, tpnme.Minus, tpnme.Times, tpnme.Div, tpnme.Mod,
+    tpnme.Lt, tpnme.Gt, tpnme.Ge, tpnme.Le,
+    tpnme.Abs, tpnme.Negate, tpnme.Min, tpnme.Max, tpnme.ToString,
+    tpnme.Not, tpnme.Xor, tpnme.And, tpnme.Or
+  )
+
   final def isCompiletimeAppliedType(sym: Symbol)(implicit ctx: Context): Boolean = {
     def isOpsPackageObjectAppliedType: Boolean =
-      sym.owner == CompiletimeOpsPackageObject.moduleClass && Set(
-        tpnme.Equals, tpnme.NotEquals,
-        tpnme.Plus, tpnme.Minus, tpnme.Times, tpnme.Div, tpnme.Mod,
-        tpnme.Lt, tpnme.Gt, tpnme.Ge, tpnme.Le,
-        tpnme.Abs, tpnme.Negate, tpnme.Min, tpnme.Max, tpnme.ToString,
-        tpnme.Not, tpnme.Xor, tpnme.And, tpnme.Or
-      ).contains(sym.name)
+      sym.owner == CompiletimeOpsPackageObject.moduleClass && compiletimePackageTypes.contains(sym.name)
 
     sym.isType && (isCompiletime_S(sym) || isOpsPackageObjectAppliedType)
   }

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

@@ -1043,7 +1043,10 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
      */
     def compareCompiletimeAppliedType(tp: AppliedType, other: Type, fromBelow: Boolean): Boolean = {
       if (defn.isCompiletime_S(tp.tycon.typeSymbol)) compareS(tp, other, fromBelow)
-      else tp.tryCompiletimeConstantFold.exists(folded => if (fromBelow) recur(other, folded) else recur(folded, other))
+      else {
+        val folded = tp.tryCompiletimeConstantFold
+        if (fromBelow) recur(other, folded) else recur(folded, other)
+      }
     }
 
     /** Like tp1 <:< tp2, but returns false immediately if we know that

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

@@ -3596,13 +3596,13 @@ object Types {
             NoType
         }
 
-        tryCompiletimeConstantFold.getOrElse(tryMatchAlias)
+        tryCompiletimeConstantFold.orElse(tryMatchAlias)
 
       case _ =>
         NoType
     }
 
-    def tryCompiletimeConstantFold(implicit ctx: Context): Option[Type] = tycon match {
+    def tryCompiletimeConstantFold(implicit ctx: Context): Type = tycon match {
       case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) =>
         def constValue(tp: Type): Option[Any] = tp match {
           case ConstantType(Constant(n)) => Some(n)
@@ -3631,7 +3631,7 @@ object Types {
           } yield ConstantType(Constant(op(a, b)))
 
         trace(i"compiletime constant fold $this", typr, show = true) {
-          if (args.length == 1) tycon.symbol.name match {
+          val constantType = if (args.length == 1) tycon.symbol.name match {
             case tpnme.S => constantFold1(natValue, _ + 1)
             case tpnme.Abs => constantFold1(intValue, _.abs)
             case tpnme.Negate => constantFold1(intValue, x => -x)
@@ -3663,9 +3663,11 @@ object Types {
             case tpnme.Xor => constantFold2(boolValue, _ ^ _)
             case _ => None
           } else None
+
+          constantType.getOrElse(NoType)
         }
 
-      case _ => None
+      case _ => NoType
     }
 
     def lowerBound(implicit ctx: Context): Type = tycon.stripTypeVar match {