Improve handling of compiletime.erasedValue

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -667,8 +667,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *                    or its type is a constant type
    *    IdempotentPath  if reference is lazy and stable
    *    Impure          otherwise
-   *  @DarkDimius: need to make sure that lazy accessor methods have Lazy and Stable
-   *               flags set.
    */
   def refPurity(tree: Tree)(using Context): PurityLevel = {
     val sym = tree.symbol

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

@@ -569,7 +569,6 @@ object Flags {
   val EnumCase: FlagSet                      = Case | Enum
   val CovariantLocal: FlagSet                = Covariant | Local                              // A covariant type parameter
   val ContravariantLocal: FlagSet            = Contravariant | Local                          // A contravariant type parameter
-  val EffectivelyErased                      = PhantomSymbol | Erased
   val ConstructorProxyModule: FlagSet        = PhantomSymbol | Module
   val CaptureParam: FlagSet                  = PhantomSymbol | StableRealizable | Synthetic
   val DefaultParameter: FlagSet              = HasDefault | Param                             // A Scala 2x default parameter

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

@@ -1051,10 +1051,14 @@ object SymDenotations {
       && owner.ne(defn.StringContextClass)
 
     /** An erased value or an erased inline method or field */
+    def isErased(using Context): Boolean =
+      is(Erased) || defn.erasedValueMethods.contains(symbol)
+
+    /** An erased value, a phantom symbol or an erased inline method or field */
     def isEffectivelyErased(using Context): Boolean =
-      isOneOf(EffectivelyErased)
+      isErased
+      || is(PhantomSymbol)
       || is(Inline) && !isRetainedInline && !hasAnnotation(defn.ScalaStaticAnnot)
-      || defn.erasedValueMethods.contains(symbol)
 
     /** Is this a member that will become public in the generated binary */
     def hasPublicInBinary(using Context): Boolean =

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

@@ -172,6 +172,19 @@ class InlineReducer(inliner: Inliner)(using Context):
 
     val isImplicit = scrutinee.isEmpty
 
+    val unusable: util.EqHashSet[Symbol] = util.EqHashSet()
+
+    /** Adjust internaly generated value definitions;
+     *   - If the RHS refers to an erased symbol, mark the val as erased
+     *   - If the RHS refers to an erased symbol, mark the val as unsuable
+     */
+    def adjustErased(sym: TermSymbol, rhs: Tree): Unit =
+      rhs.foreachSubTree:
+        case id: Ident if id.symbol.isErased =>
+          sym.setFlag(Erased)
+          if unusable.contains(id.symbol) then unusable += sym
+        case _ =>
+
     /** Try to match pattern `pat` against scrutinee reference `scrut`. If successful add
      *  bindings for variables bound in this pattern to `caseBindingMap`.
      */
@@ -184,10 +197,11 @@ class InlineReducer(inliner: Inliner)(using Context):
       /** Create a binding of a pattern bound variable with matching part of
        *  scrutinee as RHS and type that corresponds to RHS.
        */
-      def newTermBinding(sym: TermSymbol, rhs: Tree): Unit = {
-        val copied = sym.copy(info = rhs.tpe.widenInlineScrutinee, coord = sym.coord, flags = sym.flags &~ Case).asTerm
+      def newTermBinding(sym: TermSymbol, rhs: Tree): Unit =
+        val copied = sym.copy(info = rhs.tpe.widenInlineScrutinee, coord = sym.coord,
+          flags = sym.flags &~ Case).asTerm
+        adjustErased(copied, rhs)
         caseBindingMap += ((sym, ValDef(copied, constToLiteral(rhs)).withSpan(sym.span)))
-      }
 
       def newTypeBinding(sym: TypeSymbol, alias: Type): Unit = {
         val copied = sym.copy(info = TypeAlias(alias), coord = sym.coord).asType
@@ -306,6 +320,7 @@ class InlineReducer(inliner: Inliner)(using Context):
                 case (Nil, Nil) => true
                 case (pat :: pats1, selector :: selectors1) =>
                   val elem = newSym(InlineBinderName.fresh(), Synthetic, selector.tpe.widenInlineScrutinee).asTerm
+                  adjustErased(elem, selector)
                   val rhs = constToLiteral(selector)
                   elem.defTree = rhs
                   caseBindingMap += ((NoSymbol, ValDef(elem, rhs).withSpan(elem.span)))
@@ -341,16 +356,18 @@ class InlineReducer(inliner: Inliner)(using Context):
     val scrutineeSym = newSym(InlineScrutineeName.fresh(), Synthetic, scrutType).asTerm
     val scrutineeBinding = normalizeBinding(ValDef(scrutineeSym, scrutinee))
 
-    // If scrutinee has embedded `compiletime.erasedValue[T]` expressions, convert them to
-    // mark scrutineeSym as Erased. This means that the scrutinee cannot be referenced in
-    // the reduced term. It is NOT checked that scrutinee is a pure expression, since
-    // there is a special case in Erase that exempts the RHS of an erased scrutinee definition.
-    if scrutinee.existsSubTree:
-      case tree @ TypeApply(fn, args) => tree.symbol == defn.Compiletime_erasedValue
-      case _ => false
-    then
+    // If scrutinee has embedded references to `compiletime.erasedValue` or to
+    // other erased values, mark scrutineeSym as Erased. In addition, if scrutinee
+    // is not a pure expression, mark scrutineeSym as unusable. The reason is that
+    // scrutinee would then fail the tests in erasure that demand that the RHS of
+    // an erased val is a pure expression. At the end of the inline match reduction
+    // we throw out all unusable vals and check that the remaining code does not refer
+    // to unusable symbols.
+    // Note that compiletime.erasedValue is treated as erased but not pure, so scrutinees
+    // containing references to it becomes unusable.
+    if scrutinee.existsSubTree(_.symbol.isErased) then
       scrutineeSym.setFlag(Erased)
-
+      if !tpd.isPureExpr(scrutinee) then unusable += scrutineeSym
 
     def reduceCase(cdef: CaseDef): MatchReduxWithGuard = {
       val caseBindingMap = new mutable.ListBuffer[(Symbol, MemberDef)]()
@@ -393,7 +410,25 @@ class InlineReducer(inliner: Inliner)(using Context):
           case _ => None
     }
 
-    recur(cases)
+    for (bindings, expr) <- recur(cases) yield
+      // drop unusable vals and check that no referenes to unusable symbols remain
+      val cleanupUnusable = new TreeMap:
+        override def transform(tree: Tree)(using Context): Tree =
+          tree match
+            case tree: ValDef if unusable.contains(tree.symbol) => EmptyTree
+            case id: Ident if unusable.contains(id.symbol) =>
+              report.error(
+                em"""${id.symbol} is unusable in ${ctx.owner} because it refers to an erased expression
+                    |in the selector of an inline match that reduces to
+                    |
+                    |${Block(bindings, expr)}""",
+                tree.srcPos)
+              tree
+            case _ => super.transform(tree)
+
+      val bindings1 = bindings.mapConserve(cleanupUnusable.transform).collect:
+        case mdef: MemberDef => mdef
+      (bindings1, cleanupUnusable.transform(expr))
   }
 end InlineReducer
 

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -14,7 +14,7 @@ import core.Names.*
 import core.StdNames.*
 import core.NameOps.*
 import core.Periods.currentStablePeriod
-import core.NameKinds.{AdaptedClosureName, BodyRetainerName, DirectMethName, InlineScrutineeName}
+import core.NameKinds.{AdaptedClosureName, BodyRetainerName, DirectMethName}
 import core.Scopes.newScopeWith
 import core.Decorators.*
 import core.Constants.*
@@ -929,8 +929,7 @@ object Erasure {
 
     override def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree =
       if sym.isEffectivelyErased then
-        if !sym.name.is(InlineScrutineeName) then
-          checkPureErased(vdef.rhs, isArgument = false)
+        checkPureErased(vdef.rhs, isArgument = false)
         erasedDef(sym)
       else trace(i"erasing $vdef"):
         checkNotErasedClass(sym.info, vdef)

tests/neg/i23406.check

@@ -0,0 +1,40 @@
+-- Error: tests/neg/i23406.scala:18:7 ----------------------------------------------------------------------------------
+18 |  funny[String]  // error
+   |  ^^^^^^^^^^^^^
+   |  value x is unusable in method Test because it refers to an erased expression
+   |  in the selector of an inline match that reduces to
+   |
+   |  {
+   |    erased val $scrutinee1: String = compiletime.package$package.erasedValue[String]
+   |    erased val x: String = $scrutinee1
+   |    {
+   |      x:String
+   |    }
+   |  }
+   |--------------------------------------------------------------------------------------------------------------------
+   |Inline stack trace
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   |This location contains code that was inlined from i23406.scala:7
+ 7 |    case x: String => x
+   |                      ^
+    --------------------------------------------------------------------------------------------------------------------
+-- Error: tests/neg/i23406.scala:19:9 ----------------------------------------------------------------------------------
+19 |  problem[String] // error
+   |  ^^^^^^^^^^^^^^^
+   |  value x is unusable in method Test because it refers to an erased expression
+   |  in the selector of an inline match that reduces to
+   |
+   |  {
+   |    erased val $scrutinee2: String = compiletime.package$package.erasedValue[String]
+   |    erased val x: String = $scrutinee2
+   |    {
+   |      foo(x)
+   |    }
+   |  }
+   |--------------------------------------------------------------------------------------------------------------------
+   |Inline stack trace
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   |This location contains code that was inlined from i23406.scala:11
+11 |    case x: String => foo(x)
+   |                          ^
+    --------------------------------------------------------------------------------------------------------------------

tests/neg/i23406.scala

@@ -1,5 +1,20 @@
+import language.experimental.erasedDefinitions
+
+def foo(erased x: String): String = ""
+
 inline def funny[T]: String =
   inline compiletime.erasedValue[T] match
     case x: String => x
 
-@main def Test = funny[String]  // error
+inline def problem[T]: String =
+  inline compiletime.erasedValue[T] match
+    case x: String => foo(x)
+
+inline def ok[T]: String =
+  inline compiletime.erasedValue[T] match
+    case x: String => "hi"
+
+def Test =
+  funny[String]  // error
+  problem[String] // error
+  ok[String]