Make compile-time operations on stable arguments stable

Author: mbovel

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

@@ -160,11 +160,12 @@ object Types {
       * Like in isStableMember, "stability" means idempotence.
       * Rationale: If an expression has a stable type, the expression must be idempotent, so stable types
       * must be singleton types of stable expressions. */
-    final def isStable(using Context): Boolean = stripTypeVar match {
+    final def isStable(using Context): Boolean = this match {
       case tp: TermRef => tp.symbol.isStableMember && tp.prefix.isStable || tp.info.isStable
       case _: SingletonType | NoPrefix => true
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
+      case tp: AppliedType => tp.appliedTypeIsStable
       case tp: AnnotatedType =>
         // NOTE UncheckedStableAnnot was originally meant to be put on fields,
         // not on types. Allowing it on types is a Scala 3 extension. See:
@@ -4160,11 +4161,23 @@ object Types {
     // Boolean caches: 0 = uninitialized, -1 = false, 1 = true
     private var myStableHash: Byte = 0
     private var myGround: Byte = 0
+    private var myIsStable: Byte = 0
+
 
     def isGround(acc: TypeAccumulator[Boolean])(using Context): Boolean =
       if myGround == 0 then myGround = if acc.foldOver(true, this) then 1 else -1
       myGround > 0
 
+    inline def appliedTypeIsStable(using Context): Boolean =
+      if myIsStable == 0 then
+        val isStable: Byte = tycon match
+          case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) && args.forall(_.isStable) => 1
+          case _ => -1
+        if !isProvisional then myIsStable = isStable
+        isStable > 0
+      else
+        myIsStable > 0
+
     override def underlying(using Context): Type = tycon
 
     override def superType(using Context): Type =
@@ -4242,7 +4255,7 @@ object Types {
             // final val one = 1
             // type Two = one.type + one.type
             // ```
-            case tp: TermRef => tp.underlying
+            case tp: TypeProxy if tp.underlying.isStable => tp.underlying.fixForEvaluation
             case tp => tp
           }
 

tests/neg/singleton-ops-int.scala

@@ -116,4 +116,24 @@ object Test {
 
   val t83: ToDouble[1] = 1.0
   val t84: ToDouble[2] = 2 // error
+
+  // Singletons are dereferenced
+  val t85: Int = 5
+  val t86: t85.type = t85
+  summon[t85.type + t85.type =:= t86.type + t86.type]
+
+  // Singletons are dereferenced recursively
+  val t87: t86.type = t87
+  summon[t85.type + t85.type =:= t87.type + t87.type]
+
+  // Skolems of compile-time types are dereferenced:
+  // (?1 : (Test.x : Int) * (Test.x : Int)) --> (Test.x : Int) * (Test.x : Int)
+  def mult(x: Int, y: Int): x.type * y.type = (x * y).asInstanceOf
+  val t88: t85.type * t85.type * t85.type = mult(mult(t85, t85), t85)
+
+  // Compile-time operations with singleton arguments are singletons
+  summon[t85.type + t86.type <:< Singleton]
+
+  // Compile-time operations with non-singleton arguments are not singletons  
+  summon[t85.type + Int <:< Singleton] // error
 }