Enforce implementation restrictions

 - no nested rewrites
 - calls to rewrite unapplys only in rewrite code

Author: odersky

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

@@ -935,6 +935,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       else trySelectUnapply(qual1)(_ => notAnExtractor(sel))
     }
 
+    if (unapplyFn.symbol.isRewriteMethod)
+      checkInRewriteContext("implementation restriction: call to rewrite unapply", tree.pos)
+
     /** Add a `Bind` node for each `bound` symbol in a type application `unapp` */
     def addBinders(unapp: Tree, bound: List[Symbol]) = unapp match {
       case TypeApply(fn, args) =>

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

@@ -254,6 +254,8 @@ object PrepareInlineable {
   }
 
   def checkRewriteMethod(inlined: Symbol, body: Tree)(implicit ctx: Context) = {
+    if (ctx.outer.inRewriteMethod)
+      ctx.error(ex"implementation restriction: nested rewrite methods are not supported", inlined.pos)
     if (inlined.name == nme.unapply && tupleArgs(body).isEmpty)
       ctx.warning(
         em"rewrite unapply method can be rewritten only if its tight hand side is a tuple (e1, ..., eN)",

tests/neg/nested-rewrites.scala

@@ -0,0 +1,53 @@
+object Test {
+
+  rewrite def f1(x: Int) = {
+    rewrite def g(x: Int) = x // error: implementation restriction: nested rewrite methods are not supported
+    g(x)
+  }
+
+  rewrite def f2(x: Int) = {
+    object o {
+      rewrite def g(x: Int) = x // error: implementation restriction: nested rewrite methods are not supported
+    }
+    o.g(x)
+  }
+}
+object Test0 {
+
+  def f(x: Int) = {
+    rewrite def g(x: Int) = rewrite x match {
+      case 0 => 0
+    }
+    g(0)
+    transparent val Y = 0
+    g(Y)
+
+    rewrite def h(x: Int) = rewrite x match {
+      case Y => 0
+    }
+    h(0)
+  }
+
+  f(0)
+
+}
+
+object Test1 {
+
+  erased rewrite def f(x: Int) = {
+    erased rewrite def g(x: Int) = rewrite x match { // error: implementation restriction: nested rewrite methods are not supported
+      case 0 => 0
+    }
+    g(0)
+    transparent val Y = 0
+    g(Y)
+
+    rewrite def h(x: Int) = rewrite x match { // error: implementation restriction: nested rewrite methods are not supported
+      case Y => 0
+    }
+    h(0)
+  }
+
+  f(0)
+
+}

tests/neg/tuple-patterns2.scala

@@ -0,0 +1,5 @@
+object Test {
+  (1, 2) match {
+    case x *: xs =>  // error: call to rewrite unapply
+  }
+}

tests/pos/transparent-nested.scala

@@ -10,7 +10,7 @@ object Test {
     println(power2(x3))
   }
 
-  rewrite def power2(x: Double) = {
+  def power2(x: Double) = {
     rewrite def power(x: Double, transparent n: Long) = ~PowerMacro.powerCode('(x), n)
     power(x, 2)
   }