Treat unapply/unapplySeq more systematically

Author: odersky

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

@@ -71,6 +71,7 @@ object NameOps {
     def isSelectorName: Boolean = testSimple(n => n.startsWith("_") && n.drop(1).forall(_.isDigit))
     def isAnonymousClassName: Boolean = name.startsWith(str.ANON_CLASS)
     def isAnonymousFunctionName: Boolean = name.startsWith(str.ANON_FUN)
+    def isUnapplyName: Boolean = name == nme.unapply || name == nme.unapplySeq
 
     /** Is name a variable name? */
     def isVariableName: Boolean = testSimple { n =>

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

@@ -28,6 +28,7 @@ import Decorators._
 import ErrorReporting.{err, errorType}
 import config.Printers.{typr, patmatch}
 import NameKinds.DefaultGetterName
+import NameOps._
 import SymDenotations.{NoCompleter, NoDenotation}
 import Applications.unapplyArgs
 import transform.patmat.SpaceEngine.isIrrefutableUnapply
@@ -733,7 +734,7 @@ trait Checking {
     def isInfix(sym: Symbol): Boolean =
       sym.hasAnnotation(defn.InfixAnnot) ||
       defn.isInfix(sym) ||
-      (sym.name == nme.unapply || sym.name == nme.unapplySeq) &&
+      sym.name.isUnapplyName &&
         sym.owner.is(Module) && sym.owner.linkedClass.is(Case) &&
         isInfix(sym.owner.linkedClass)
 
@@ -1038,7 +1039,7 @@ trait Checking {
   def checkInInlineContext(what: String, posd: Positioned)(implicit ctx: Context): Unit =
     if (!ctx.inInlineMethod && !ctx.isInlineContext) {
       val inInlineUnapply = ctx.owner.ownersIterator.exists(owner =>
-        owner.name == nme.unapply && owner.is(Inline) && owner.is(Method))
+        owner.name.isUnapplyName && 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"

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

@@ -14,6 +14,7 @@ import StdNames.nme
 import Contexts.Context
 import Names.Name
 import NameKinds.{InlineAccessorName, UniqueInlineName}
+import NameOps._
 import Annotations._
 import transform.{AccessProxies, PCPCheckAndHeal, Splicer, TreeMapWithStages}
 import config.Printers.inlining
@@ -246,7 +247,7 @@ object PrepareInlineable {
   def checkInlineMethod(inlined: Symbol, body: Tree)(implicit ctx: Context): Unit = {
     if (ctx.outer.inInlineMethod)
       ctx.error(ex"implementation restriction: nested inline methods are not supported", inlined.sourcePos)
-    if (inlined.name == nme.unapply && tupleArgs(body).isEmpty)
+    if (inlined.name.isUnapplyName && tupleArgs(body).isEmpty)
       ctx.warning(
         em"inline unapply method can be rewritten only if its right hand side is a tuple (e1, ..., eN)",
         body.sourcePos)