Make implicit match imply erased

Author: odersky

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

@@ -974,9 +974,11 @@ 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.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)
+        if (tree.getAttachment(PrepareTransparent.TopLevelMatch).isDefined)
+          ctx.owner.setFlag(Erased)
+        else
+          ctx.error(em"implicit match cannot be used here; it must occur as a toplevel match of a transparent method", tree.pos)
+
         val sel1 = id.withType(defn.ImplicitScrutineeTypeRef)
         typedMatchFinish(tree, sel1, sel1.tpe, pt)
       case _ =>

docs/docs/typelevel.md

@@ -233,7 +233,7 @@ The following rewrite rules are performed when simplifying inlined bodies:
 
 Transparent methods are effectively final; they may not be overwritten.
 
-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:
+Transparent methods with a toplevel implicit match or macro splice are classified `erased` - an `erased` modifier can be given for them, but it is redundant. Erased transparent methods must be always fully applied. In addition, the restrictions on normal erased methods apply, including:
 
  1. They may not override other methods.
  2. They may not be referred to from a non-erased context.
@@ -409,7 +409,8 @@ 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 methods that are both `erased` and `transparent`. This ensures that all implicit searches are done at compile-time.
+Implicit matches can only occur as toplevel match expressions of a `transparent` method.
+If a transpatent method contains implicit matches, it is classified as `erased` - an `erased` modifier can be given for it, but it is redundant. 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
 
-  erased transparent def f: Any = implicit match {
+  transparent def f: Any = implicit match {
     case _: A => ???  // error: ambiguous implicits
   }
 

tests/neg/implicitMatch-syntax.scala

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