Remove tryCompiletimeConstantFold from tryNormalize

This is another step needed to make
`tryNormalize.exists ==> underlyingMatchType.exists`

In fact, `tryNormalize.exists` could be true
without having a single match type involved.

Author: EugeneFlesselle

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

@@ -116,7 +116,7 @@ class CheckRealizable(using Context) {
     case _: SingletonType | NoPrefix =>
       Realizable
     case tp =>
-      def isConcrete(tp: Type): Boolean = tp.dealias match {
+      def isConcrete(tp: Type): Boolean = tp.dealias.compiletimeConstantFolded match {
         case tp: TypeRef => tp.symbol.isClass
         case tp: TypeParamRef => false
         case tp: TypeProxy => isConcrete(tp.underlying)

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

@@ -12,7 +12,7 @@ object TypeEval:
   def tryCompiletimeConstantFold(tp: AppliedType)(using Context): Type = tp.tycon match
     case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) =>
       extension (tp: Type) def fixForEvaluation: Type =
-        tp.normalized.dealias match
+        tp.normalized.dealias.compiletimeConstantFolded match
           // enable operations for constant singleton terms. E.g.:
           // ```
           // final val one = 1

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

@@ -1524,6 +1524,11 @@ object Types extends TypeUtils {
       }
       deskolemizer(this)
 
+    /** Contant fold applied compiletime ops if possible */
+    final def compiletimeConstantFolded(using Context) = this match
+      case tp: AppliedType => tp.tryCompiletimeConstantFold.orElse(this)
+      case tp => tp
+
     /** The result of normalization using `tryNormalize`, or the type itself if
      *  tryNormlize yields NoType
      */
@@ -4651,14 +4656,9 @@ object Types extends TypeUtils {
       cachedUnderlyingMatch
 
     override def tryNormalize(using Context): Type =
-      def tryMatchAlias =
-        if isMatchAlias then trace(i"normalize $this", typr, show = true):
-          if MatchTypeTrace.isRecording then
-            MatchTypeTrace.recurseWith(this)(superType.tryNormalize)
-          else
-            underlyingMatchType.tryNormalize
-        else NoType
-      tryCompiletimeConstantFold.orElse(tryMatchAlias)
+      if MatchTypeTrace.isRecording && isMatchAlias then
+        MatchTypeTrace.recurseWith(this)(superType.tryNormalize)
+      else super.tryNormalize
 
     /** Is this an unreducible application to wildcard arguments?
      *  This is the case if tycon is higher-kinded. This means
@@ -5160,7 +5160,8 @@ object Types extends TypeUtils {
           myReduced = trace(i"reduce match type $this $hashCode", matchTypes, show = true):
             withMode(Mode.Type):
               TypeComparer.reduceMatchWith: cmp =>
-                cmp.matchCases(scrutinee.normalized, cases.map(MatchTypeCaseSpec.analyze))
+                val scrutNormed = scrutinee.normalized.compiletimeConstantFolded
+                cmp.matchCases(scrutNormed, cases.map(MatchTypeCaseSpec.analyze))
         catch case ex: Throwable =>
           myReduced = NoType
           handleRecursive("reduce type ", i"$scrutinee match ...", ex)

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

@@ -224,7 +224,8 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       New(defn.ValueOfClass.typeRef.appliedTo(t.tpe), t :: Nil).withSpan(span)
     formal.argInfos match
       case arg :: Nil =>
-        fullyDefinedType(arg, "ValueOf argument", ctx.source.atSpan(span)).normalized.dealias match
+        val arg1 = fullyDefinedType(arg, "ValueOf argument", ctx.source.atSpan(span))
+        arg1.normalized.dealias.compiletimeConstantFolded match
           case ConstantType(c: Constant) =>
             withNoErrors(success(Literal(c)))
           case tp: TypeRef if tp.isRef(defn.UnitClass) =>

tests/neg/singleton-ops-any.check

@@ -2,28 +2,28 @@
 6 |  val t34: 10 == "5" = true // error
   |                       ^^^^
   |                       Found:    (true : Boolean)
-  |                       Required: (false : Boolean)
+  |                       Required: (10 : Int) == ("5" : String)
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg/singleton-ops-any.scala:7:22 --------------------------------------------------
 7 |  val t35: 10 == 10 = false // error
   |                      ^^^^^
   |                      Found:    (false : Boolean)
-  |                      Required: (true : Boolean)
+  |                      Required: (10 : Int) == (10 : Int)
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg/singleton-ops-any.scala:12:24 -------------------------------------------------
 12 |  val t38: false != 5 = false // error
    |                        ^^^^^
    |                        Found:    (false : Boolean)
-   |                        Required: (true : Boolean)
+   |                        Required: (false : Boolean) != (5 : Int)
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg/singleton-ops-any.scala:13:22 -------------------------------------------------
 13 |  val t39: 10 != 10 = true // error
    |                      ^^^^
    |                      Found:    (true : Boolean)
-   |                      Required: (false : Boolean)
+   |                      Required: (10 : Int) != (10 : Int)
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg/singleton-ops-any.scala:18:27 -------------------------------------------------
@@ -37,6 +37,6 @@
 32 |  val t48: IsConst[Any] = true // error
    |                          ^^^^
    |                          Found:    (true : Boolean)
-   |                          Required: (false : Boolean)
+   |                          Required: scala.compiletime.ops.any.IsConst[Any]
    |
    | longer explanation available when compiling with `-explain`