Decouple transparent and erased properties

It is at times useful to have `transparent` methods that are not
`erased`. For instance, a transparent `unapply` might enable inline
reductions, but we want to also keep it at runtime, because the same
type might be matched at compile-time and at run-time.

This commit decouples `transparent` and `erased` again. `transparent`
does not imply `erased`.

Author: odersky

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -160,7 +160,7 @@ object Config {
   final val showCompletions = false
 
   /** If set, enables tracing */
-  final val tracingEnabled = false
+  final val tracingEnabled = true
 
   /** Initial capacity of uniques HashMap.
    *  Note: This MUST BE a power of two to work with util.HashSet

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

@@ -548,8 +548,8 @@ object Flags {
   /** Assumed to be pure */
   final val StableOrErased = Stable | Erased
 
-  /** Labeled `private`, `final`, or `transparent` */
-  final val EffectivelyFinal = Private | Final | Transparent
+  /** Labeled `private`, `final`, `transparent`, or `erasedd` */
+  final val EffectivelyFinal = Private | Final | Transparent | Erased
 
   /** A private method */
   final val PrivateMethod = allOf(Private, Method)
@@ -563,6 +563,9 @@ object Flags {
   /** A transparent parameter */
   final val TransparentParam = allOf(Transparent, Param)
 
+  /** A transparent erased method */
+  final val TransparentErasedMethod = allOf(Transparent, Erased, Method)
+
   /** An enum case */
   final val EnumCase = allOf(Enum, Case)
 

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -761,7 +761,7 @@ class ClassfileParser(
           assert(cond,
             s"Unpickling ${classRoot.symbol.showLocated} from ${classRoot.symbol.associatedFile} is not allowed with -Yscala2-unpickler $allowed")
 
-        if (allowed != "always") {
+        if (false && allowed != "always") {
           failUnless(allowed != "never")
           val allowedList = allowed.split(":").toList
           val file = classRoot.symbol.associatedFile

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

@@ -165,9 +165,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
 
       def markAsMacro(c: Context): Unit =
         if (c.owner eq c.outer.owner) markAsMacro(c.outer)
-        else if (c.owner.isTransparentMethod) {
-          c.owner.setFlag(Macro)
-        }
+        else if (c.owner.isTransparentMethod) c.owner.setFlag(Macro | Erased)
         else if (!c.outer.owner.is(Package)) markAsMacro(c.outer)
 
       if (sym.isSplice || sym.isQuote) {

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

@@ -1195,15 +1195,6 @@ class Namer { typer: Typer =>
       instantiateDependent(restpe, typeParams, termParamss)
       ctx.methodType(tparams map symbolOfTree, termParamss, restpe, isJava = ddef.mods is JavaDefined)
     }
-    if (sym.is(Transparent) &&
-        sym.unforcedAnnotation(defn.ForceInlineAnnot).isEmpty)
-        // Need to keep @forceInline annotated methods around to get to parity with Scala.
-        // This is necessary at least until we have full bootstrap. Right now
-        // dotty-bootstrapped involves running the Dotty compiler compiled with Scala 2 with
-        // a Dotty runtime library compiled with Dotty. If we erase @forceInline annotated
-        // methods, this means that the support methods in dotty.runtime.LazyVals vanish.
-        // But they are needed for running the lazy val implementations in the Scala-2 compiled compiler.
-      sym.setFlag(Erased)
     if (isConstructor) {
       // set result type tree to unit, but take the current class as result type of the symbol
       typedAheadType(ddef.tpt, defn.UnitType)

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

@@ -143,7 +143,7 @@ object RefChecks {
    *    1.8.1  M's type is a subtype of O's type, or
    *    1.8.2  M is of type []S, O is of type ()T and S <: T, or
    *    1.8.3  M is of type ()S, O is of type []T and S <: T, or
-   *    1.9    M must not be a typelevel def or a Dotty macro def
+   *    1.9    M must not be an erased definition
    *    1.10.  If M is a 2.x macro def, O cannot be deferred unless there's a concrete method overriding O.
    *    1.11.  If M is not a macro def, O cannot be a macro def.
    *  2. Check that only abstract classes have deferred members
@@ -376,8 +376,8 @@ object RefChecks {
         overrideError("may not override a non-lazy value")
       } else if (other.is(Lazy) && !other.isRealMethod && !member.is(Lazy)) {
         overrideError("must be declared lazy to override a lazy value")
-      } else if (member.is(Erased) && member.allOverriddenSymbols.forall(_.is(Deferred))) { // (1.9)
-        overrideError("is an erased method, may not override only deferred methods")
+      } else if (member.is(Erased)) { // (1.9)
+        overrideError("is an erased method, may not override anything")
       } else if (member.is(Macro, butNot = Scala2x)) { // (1.9)
         overrideError("is a macro, may not override anything")
       } else if (other.is(Deferred) && member.is(Scala2Macro) && member.extendedOverriddenSymbols.forall(_.is(Deferred))) { // (1.10)

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

@@ -974,8 +974,9 @@ class Typer extends Namer
         val unchecked = pt.isRef(defn.PartialFunctionClass)
         typed(desugar.makeCaseLambda(tree.cases, protoFormals.length, unchecked) withPos tree.pos, pt)
       case id @ untpd.ImplicitScrutinee() =>
-        if (tree.getAttachment(PrepareTransparent.TopLevelMatch).isEmpty)
-          ctx.error(em"implicit match cannot be used here; it must occur as a toplevel match of a transparent method", tree.pos)
+        if (tree.getAttachment(PrepareTransparent.TopLevelMatch).isEmpty ||
+            !ctx.owner.flagsUNSAFE.is(Erased))
+          ctx.error(em"implicit match cannot be used here; it must occur as a toplevel match of an erased transparent method", tree.pos)
         val sel1 = id.withType(defn.ImplicitScrutineeTypeRef)
         typedMatchFinish(tree, sel1, sel1.tpe, pt)
       case _ =>
@@ -2351,7 +2352,7 @@ class Typer extends Namer
       //  - the current tree is a synthetic apply which is not expandable (eta-expasion would simply undo that)
       if (arity >= 0 &&
           !tree.symbol.isConstructor &&
-          !tree.symbol.is(TransparentMethod) &&
+          !tree.symbol.is(TransparentErasedMethod) &&
           !ctx.mode.is(Mode.Pattern) &&
           !(isSyntheticApply(tree) && !isExpandableApply))
         simplify(typed(etaExpand(tree, wtp, arity), pt), pt, locked)

docs/docs/typelevel.md

@@ -229,34 +229,17 @@ The following rewrite rules are performed when simplifying inlined bodies:
    Dropping a binding might make other bindings redundant. Garbage collection proceeds until no further bindings
    can be dropped.
 
-## Restrictions for Transparent and Typelevel Functions
+## Restrictions for Transparent and Erased Functions
 
 Transparent methods are effectively final; they may not be overwritten.
 
-If a transparent
-method has a toplevel match expression or a toplevel splice `~` on its right-hand side,
-it is classified as a typelevel method that can _only_ be executed at compile time. For typelevel methods two more restrictions apply:
+Transparent methods with an implicit match expression on their right-hand side must in addition be declared `erased`. Erased transparent methods must be always fully applied. In addition, the restrictions on normal erased methods apply, including:
 
- 1. They must be always fully applied.
- 2. They may override other methods only if one of the overridden methods is concrete.
+ 1. They may not override other methods.
+ 2. They may not be referred to from a non-erased context.
 
-The right hand side of a typelevel method is never invoked by dynamic dispatch. As an example consider a situation like the following:
-```scala
-class Iterable[T] {
-  def foreach(f: T => Unit): Unit = ...
-}
-class List[T] extends Iterable[T] {
-  override transparent def foreach(f: T => Unit): Unit = ...
-}
-val xs: Iterable[T] = ...
-val ys: List[T] = ...
-val zs: Iterable[T] = ys
-xs.foreach(f)  // calls Iterable's foreach
-ys.foreach(f)  // expands to the body of List's foreach
-zs.foreach(f)  // calls Iterable's foreach
-```
-It follows that an overriding typelevel method should implement exactly the same semantics as the
-method it overrides (but possibly more efficiently).
+**Question:** We currently set `erased` automatically for macros, i.e. methods with a
+right-hand side of the form `~...`. But we require it to be written explicitly for methods that have an implicit match as RHS. Should these situations be treated in the same instead? If yes, which of the two is preferable?
 
 ## Matching on Types
 
@@ -415,7 +398,7 @@ There are some proposals to improve the situation in specific areas, for instanc
 By contrast, the new `implicit match` construct makes implicit search available in a functional context. To solve
 the problem of creating the right set, one would use it as follows:
 ```scala
-transparent def setFor[T]: Set[T] = implicit match {
+erased transparent def setFor[T]: Set[T] = implicit match {
   case ord: Ordering[T] => new TreeSet[T]
   case _                => new HashSet[T]
 }
@@ -426,8 +409,7 @@ Patterns are tried in sequence. The first case with a pattern `x: T` such that a
 of type `T` can be summoned is chosen. The variable `x` is then bound to the implicit value for the remainder of the case. It can in turn be used as an implicit in the right hand side of the case.
 It is an error if one of the tested patterns gives rise to an ambiguous implicit search.
 
-Implicit matches can only occur as toplevel match expressions of transparent methods. This ensures that
-all implicit searches are done at compile-time.
+Implicit matches can only occur as toplevel match expressions of methods that are both `erased` and `transparent`. This ensures that all implicit searches are done at compile-time.
 
 ## Transparent Values
 

tests/neg/implicitMatch-ambiguous.scala

@@ -4,7 +4,7 @@ object Test {
   implicit val a1: A = new A
   implicit val a2: A = new A
 
-  transparent def f: Any = implicit match {
+  erased transparent def f: Any = implicit match {
     case _: A => ???  // error: ambiguous implicits
   }
 

tests/neg/implicitMatch-syntax.scala

@@ -2,32 +2,36 @@ object Test {
   import collection.immutable.TreeSet
   import collection.immutable.HashSet
 
-  transparent def f1[T] = implicit implicit match { // error: repeated modifier // error: illegal modifier
+  erased transparent def f1[T] = implicit implicit match { // error: repeated modifier // error: illegal modifier
     case ord: Ordered[T] => new TreeSet[T] // error: no implicit
     case _ => new HashSet[T]
 
   }
 
-  transparent def f2[T] = implicit erased match { // error: illegal modifier
+  erased transparent def f2[T] = implicit erased match { // error: illegal modifier
     case ord: Ordered[T] => new TreeSet[T] // error: no implicit
     case _ => new HashSet[T]
   }
 
-  transparent def f3[T] = erased implicit match { // error: illegal modifier
+  erased transparent def f3[T] = erased implicit match { // error: illegal modifier
     case ord: Ordered[T] => new TreeSet[T] // error: no implicit
     case _ => new HashSet[T]
   }
 
-  transparent def f4() = implicit match {
+  erased transparent def f4() = implicit match {
     case Nil => ???     // error: not a legal pattern
     case x :: xs => ??? // error: not a legal pattern
   }
 
-  transparent def f5[T] = locally { implicit match { // error: implicit match cannot be used here
+  erased transparent def f5[T] = locally { implicit match { // error: implicit match cannot be used here
     case _ => new HashSet[T]
   }}
 
-  def f6[T] = implicit match { // error: implicit match cannot be used here
+  transparent def f6[T] = implicit match { // error: implicit match cannot be used here
+    case _ => new HashSet[T]
+  }
+
+  erased def f7[T] = implicit match { // error: implicit match cannot be used here
     case _ => new HashSet[T]
   }
 }