Redo tryCompiletimeConstantFold in tryNormalize

But with caching

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.compiletimeConstantFolded match {
+      def isConcrete(tp: Type): Boolean = tp.dealias 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.compiletimeConstantFolded match
+        tp.normalized.dealias match
           // enable operations for constant singleton terms. E.g.:
           // ```
           // final val one = 1

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

@@ -143,7 +143,7 @@ object TypeOps:
         defn.MatchCase(simplify(pat, theMap), body)
       case tp: AppliedType =>
         if tp.isMatchAlias then isFullyDefined(tp, ForceDegree.all)
-        val normed = tp.tryNormalize.orElse(tp.tryCompiletimeConstantFold)
+        val normed = tp.tryNormalize
         if normed.exists then simplify(normed, theMap) else tp.map(simplify(_, theMap))
       case tp: TypeParamRef =>
         val tvar = ctx.typerState.constraint.typeVarOfParam(tp)

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

@@ -466,7 +466,7 @@ object Types extends TypeUtils {
       case _ => false
 
     /** Does this application expand to a match type? */
-    def isMatchAlias(using Context): Boolean = underlyingMatchType.exists
+    def isMatchAlias(using Context): Boolean = underlyingNormalizable.isMatch
 
     /** Is this a higher-kinded type lambda with given parameter variances?
      *  These lambdas are used as the RHS of higher-kinded abstract types or
@@ -1519,27 +1519,23 @@ object Types extends TypeUtils {
       }
       deskolemizer(this)
 
-    /** Constant fold applied compiletime operations if possible */
-    final def compiletimeConstantFolded(using Context) = this match
-      case tp: AppliedType => tp.tryCompiletimeConstantFold.orElse(this)
-      case tp => tp
-
     /** The result of normalization, or the type itself if none apply. */
     final def normalized(using Context): Type = tryNormalize.orElse(this)
 
-    /** If this type has an underlying match type, the result after applying all
-     *  toplevel normalizations, otherwise NoType.
+    /** If this type has an underlying match type or applied compiletime.ops,
+     *  then the result after applying all toplevel normalizations, otherwise NoType.
      */
-    def tryNormalize(using Context): Type = underlyingMatchType match
+    def tryNormalize(using Context): Type = underlyingNormalizable match
       case mt: MatchType => mt.reduced.normalized
+      case tp: AppliedType => tp.tryCompiletimeConstantFold
       case _ => NoType
 
     /** Perform successive dealiasings and beta-reductions of applied types until
      *  a match type is reached if any, otherwise NoType.
      */
-    def underlyingMatchType(using Context): Type = this.safeDealias.stripLazyRef match
+    def underlyingNormalizable(using Context): Type = this.safeDealias.stripLazyRef match
       case tp: MatchType => tp
-      case tp: AppliedType => tp.underlyingMatchType
+      case tp: AppliedType => tp.underlyingNormalizable
       case _ => NoType
 
     private def widenDealias1(keep: AnnotatedType => Context ?=> Boolean)(using Context): Type = {
@@ -4586,8 +4582,8 @@ object Types extends TypeUtils {
     private var myEvalRunId: RunId = NoRunId
     private var myEvalued: Type = uninitialized
 
-    private var validUnderlyingMatch: Period = Nowhere
-    private var cachedUnderlyingMatch: Type = uninitialized
+    private var validUnderlyingNormalizable: Period = Nowhere
+    private var cachedUnderlyingNormalizable: Type = uninitialized
 
     def isGround(acc: TypeAccumulator[Boolean])(using Context): Boolean =
       if myGround == 0 then myGround = if acc.foldOver(true, this) then 1 else -1
@@ -4649,11 +4645,13 @@ object Types extends TypeUtils {
      *  Anything else should have already been reduced in `appliedTo` by the TypeAssigner.
      *  May reduce several HKTypeLambda applications before the underlying MatchType is reached.
      */
-    override def underlyingMatchType(using Context): Type =
-      if ctx.period != validUnderlyingMatch then
-        validUnderlyingMatch = if tycon.isProvisional then Nowhere else ctx.period
-        cachedUnderlyingMatch = superType.underlyingMatchType
-      cachedUnderlyingMatch
+    override def underlyingNormalizable(using Context): Type =
+      if ctx.period != validUnderlyingNormalizable then
+        validUnderlyingNormalizable = if tycon.isProvisional then Nowhere else ctx.period
+        cachedUnderlyingNormalizable = tycon match
+          case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) => this
+          case _ => superType.underlyingNormalizable
+      cachedUnderlyingNormalizable
 
     override def tryNormalize(using Context): Type =
       if MatchTypeTrace.isRecording && isMatchAlias then
@@ -5153,8 +5151,7 @@ object Types extends TypeUtils {
           myReduced = trace(i"reduce match type $this $hashCode", matchTypes, show = true):
             withMode(Mode.Type):
               TypeComparer.reduceMatchWith: cmp =>
-                val scrutNormed = scrutinee.normalized.compiletimeConstantFolded
-                cmp.matchCases(scrutNormed, cases.map(MatchTypeCaseSpec.analyze))
+                cmp.matchCases(scrutinee.normalized, cases.map(MatchTypeCaseSpec.analyze))
         catch case ex: Throwable =>
           myReduced = NoType
           handleRecursive("reduce type ", i"$scrutinee match ...", ex)
@@ -5188,7 +5185,7 @@ object Types extends TypeUtils {
     def apply(bound: Type, scrutinee: Type, cases: List[Type])(using Context): MatchType =
       unique(new CachedMatchType(bound, scrutinee, cases))
 
-    def thatReducesUsingGadt(tp: Type)(using Context): Boolean = tp.underlyingMatchType match
+    def thatReducesUsingGadt(tp: Type)(using Context): Boolean = tp.underlyingNormalizable match
       case mt: MatchType => mt.reducesUsingGadt
       case _ => false
 

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -445,15 +445,13 @@ object Inlines:
                 evidence
           }
 
-        def unrollTupleTypes(tpe: Type): Option[List[Type]] = tpe.dealias match
+        def unrollTupleTypes(tpe: Type): Option[List[Type]] = tpe.dealias.normalized match
           case AppliedType(tycon, args) if defn.isTupleClass(tycon.typeSymbol) =>
             Some(args)
           case AppliedType(tycon, head :: tail :: Nil) if tycon.isRef(defn.PairClass) =>
             unrollTupleTypes(tail).map(head :: _)
           case tpe: TermRef if tpe.symbol == defn.EmptyTupleModule =>
             Some(Nil)
-          case tpe: AppliedType if tpe.isMatchAlias =>
-            unrollTupleTypes(tpe.tryNormalize)
           case _ =>
             None
 

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

@@ -224,8 +224,7 @@ 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 =>
-        val arg1 = fullyDefinedType(arg, "ValueOf argument", ctx.source.atSpan(span))
-        arg1.normalized.dealias.compiletimeConstantFolded match
+        fullyDefinedType(arg, "ValueOf argument", ctx.source.atSpan(span)).normalized.dealias match
           case ConstantType(c: Constant) =>
             withNoErrors(success(Literal(c)))
           case tp: TypeRef if tp.isRef(defn.UnitClass) =>

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

@@ -1847,7 +1847,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               case _ => false
             }
 
-        val result = pt.underlyingMatchType match {
+        val result = pt.underlyingNormalizable match {
           case mt: MatchType if isMatchTypeShaped(mt) =>
             typedDependentMatchFinish(tree, sel1, selType, tree.cases, mt)
           case _ =>

tests/neg/singleton-ops-any.check

@@ -2,28 +2,28 @@
 6 |  val t34: 10 == "5" = true // error
   |                       ^^^^
   |                       Found:    (true : Boolean)
-  |                       Required: (10 : Int) == ("5" : String)
+  |                       Required: (false : Boolean)
   |
   | 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: (10 : Int) == (10 : Int)
+  |                      Required: (true : Boolean)
   |
   | 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: (false : Boolean) != (5 : Int)
+   |                        Required: (true : Boolean)
    |
    | 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: (10 : Int) != (10 : Int)
+   |                      Required: (false : Boolean)
    |
    | 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: scala.compiletime.ops.any.IsConst[Any]
+   |                          Required: (false : Boolean)
    |
    | longer explanation available when compiling with `-explain`