Allow inline unapply

Unapply methods can have `inline` flags. This enables reduceProjection to see
the methods right hand side. On the other hand, since `unapply` methods are not
applied hen used in patterns we do not classify them as inline methods. Consequently
they cannot contain inline matches or inline ifs.

Author: odersky

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

@@ -793,7 +793,10 @@ object SymDenotations {
     def isSkolem: Boolean = name == nme.SKOLEM
 
     def isInlineMethod(implicit ctx: Context): Boolean =
-      is(InlineMethod, butNot = AccessorOrSynthetic)
+      is(InlineMethod, butNot = AccessorOrSynthetic) &&
+      name != nme.unapply  // unapply methods do not count as inline methods
+                           // we need an inline flag on them only do that
+                           // reduceProjection gets access to their rhs
 
     /** An erased value or an inline method, excluding @forceInline annotated methods.
      *  The latter have to be kept around to get to parity with Scala.

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

@@ -982,14 +982,6 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       else trySelectUnapply(qual1)(_ => notAnExtractor(sel))
     }
 
-    /* Can probably be dropped. The idea is that inline unapply methods are available
-     * for inspection in the Inliner's reduceMatch method, but are never inlined
-     * when called from normal code.
-
-    if (unapplyFn.symbol.isInlineMethod)
-      checkInInlineContext("implementation restriction: call to inline 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/Checking.scala

@@ -891,8 +891,14 @@ trait Checking {
 
   /** Check that we are in an inline context (inside an inline method or in inline code) */
   def checkInInlineContext(what: String, pos: Position)(implicit ctx: Context): Unit =
-    if (!ctx.inInlineMethod && !ctx.isInlineContext)
-      ctx.error(em"$what can only be used in an inline method", pos)
+    if (!ctx.inInlineMethod && !ctx.isInlineContext) {
+      val inInlineUnapply = ctx.owner.ownersIterator.exists(owner =>
+        owner.name == nme.unapply && owner.is(Inline) && owner.is(Method))
+      val msg =
+        if (inInlineUnapply) "cannot be used in an inline unapply"
+        else "can only be used in an inline method"
+      ctx.error(em"$what $msg", pos)
+    }
 
   /** Check that all case classes that extend `scala.Enum` are `enum` cases */
   def checkEnum(cdef: untpd.TypeDef, cls: Symbol, parent: Symbol)(implicit ctx: Context): Unit = {