Implement @infix for types and patterns

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1401,13 +1401,6 @@ object desugar {
         }
         // This is a deliberate departure from scalac, where StringContext is not rooted (See #4732)
         Apply(Select(Apply(scalaDot(nme.StringContext), strs), id), elems)
-      case InfixOp(l, op, r) =>
-        if (ctx.mode is Mode.Type)
-          AppliedTypeTree(op, l :: r :: Nil) // op[l, r]
-        else {
-          assert(ctx.mode is Mode.Pattern) // expressions are handled separately by `binop`
-          Apply(op, l :: r :: Nil) // op(l, r)
-        }
       case PostfixOp(t, op) =>
         if ((ctx.mode is Mode.Type) && !op.isBackquoted && op.name == tpnme.raw.STAR) {
           val seqType = if (ctx.compilationUnit.isJava) defn.ArrayType else defn.SeqType

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -697,8 +697,9 @@ object Trees {
    *    if (result.isDefined) "match patterns against result"
    */
   case class UnApply[-T >: Untyped] private[ast] (fun: Tree[T], implicits: List[Tree[T]], patterns: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
-    extends PatternTree[T] {
+    extends ProxyTree[T] with PatternTree[T] {
     type ThisTree[-T >: Untyped] = UnApply[T]
+    def forwardTo = fun
   }
 
   /** mods val name: tpt = rhs */

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

@@ -675,28 +675,47 @@ trait Checking {
   /** Check that `tree` is a valid infix operation. That is, if the
    *  operator is alphanumeric, it must be declared `@infix`.
    */
-  def checkValidInfix(tree: untpd.InfixOp, app: Tree)(implicit ctx: Context): Unit =
+  def checkValidInfix(tree: untpd.InfixOp, meth: Symbol)(implicit ctx: Context): Unit = {
+
+    def isInfix(sym: Symbol): Boolean =
+      sym.hasAnnotation(defn.InfixAnnot) ||
+      defn.isInfix(sym) ||
+      (sym.name == nme.unapply || sym.name == nme.unapplySeq) &&
+        sym.owner.is(Module) && sym.owner.linkedClass.is(Case) &&
+        isInfix(sym.owner.linkedClass)
+
     tree.op match {
       case _: untpd.BackquotedIdent =>
         ()
-      case Ident(name: SimpleName)
-      if !name.exists(isOperatorPart) &&
-         !app.symbol.hasAnnotation(defn.InfixAnnot) &&
-         !defn.isInfix(app.symbol) &&
-         !app.symbol.maybeOwner.is(Scala2x) &&
-         !infixOKSinceFollowedBy(tree.right) &&
-         ctx.settings.strict.value =>
-        ctx.deprecationWarning(
-          i"""Alphanumeric method $name is not declared @infix; it should not be used as infix operator.
-             |The operation can be rewritten automatically to `$name` under -deprecation -rewrite.
-             |Or rewrite to method syntax .$name(...) manually.""",
-          tree.op.sourcePos)
-        if (ctx.settings.deprecation.value) {
-          patch(Span(tree.op.span.start, tree.op.span.start), "`")
-          patch(Span(tree.op.span.end, tree.op.span.end), "`")
+      case Ident(name: Name) =>
+        name.toTermName match {
+          case name: SimpleName
+          if !name.exists(isOperatorPart) &&
+            !isInfix(meth) &&
+            !meth.maybeOwner.is(Scala2x) &&
+            !infixOKSinceFollowedBy(tree.right) &&
+            ctx.settings.strict.value =>
+            val (kind, alternative) =
+              if (ctx.mode.is(Mode.Type))
+                ("type", (n: Name) => s"prefix syntax $n[...]")
+              else if (ctx.mode.is(Mode.Pattern))
+                ("extractor", (n: Name) => s"prefix syntax $n(...)")
+              else
+                ("method", (n: Name) => s"method syntax .$n(...)")
+            ctx.deprecationWarning(
+              i"""Alphanumeric $kind $name is not declared @infix; it should not be used as infix operator.
+                 |The operation can be rewritten automatically to `$name` under -deprecation -rewrite.
+                 |Or rewrite to ${alternative(name)} manually.""",
+              tree.op.sourcePos)
+            if (ctx.settings.deprecation.value) {
+              patch(Span(tree.op.span.start, tree.op.span.start), "`")
+              patch(Span(tree.op.span.end, tree.op.span.end), "`")
+            }
+          case _ =>
         }
       case _ =>
     }
+  }
 
   /** Issue a feature warning if feature is not enabled */
   def checkFeature(name: TermName,
@@ -1087,6 +1106,6 @@ trait NoChecking extends ReChecking {
   override def checkNoForwardDependencies(vparams: List[ValDef])(implicit ctx: Context): Unit = ()
   override def checkMembersOK(tp: Type, pos: SourcePosition)(implicit ctx: Context): Type = tp
   override def checkInInlineContext(what: String, posd: Positioned)(implicit ctx: Context): Unit = ()
-  override def checkValidInfix(tree: untpd.InfixOp, app: Tree)(implicit ctx: Context): Unit = ()
+  override def checkValidInfix(tree: untpd.InfixOp, meth: Symbol)(implicit ctx: Context): Unit = ()
   override def checkFeature(name: TermName, description: => String, featureUseSite: Symbol, pos: SourcePosition)(implicit ctx: Context): Unit = ()
 }

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

@@ -1874,28 +1874,39 @@ class Typer extends Namer
 
   /** Translate infix operation expression `l op r` to
    *
-   *    l.op(r)   			    if `op` is left-associative
+   *    l.op(r)   			        if `op` is left-associative
    *    { val x = l; r.op(l) }  if `op` is right-associative call-by-value and `l` is impure
    *    r.op(l)                 if `op` is right-associative call-by-name or `l` is pure
+   *
+   *  Translate infix type    `l op r` to `op[l, r]`
+   *  Translate infix pattern `l op r` to `op(l, r)`
    */
   def typedInfixOp(tree: untpd.InfixOp, pt: Type)(implicit ctx: Context): Tree = {
     val untpd.InfixOp(l, op, r) = tree
-    val app = typedApply(desugar.binop(l, op, r), pt)
-    checkValidInfix(tree, app)
-    if (untpd.isLeftAssoc(op.name)) app
-    else {
-      val defs = new mutable.ListBuffer[Tree]
-      def lift(app: Tree): Tree = (app: @unchecked) match {
-        case Apply(fn, args) =>
-          if (app.tpe.isError) app
-          else tpd.cpy.Apply(app)(fn, LiftImpure.liftArgs(defs, fn.tpe, args))
-        case Assign(lhs, rhs) =>
-          tpd.cpy.Assign(app)(lhs, lift(rhs))
-        case Block(stats, expr) =>
-          tpd.cpy.Block(app)(stats, lift(expr))
+    val result =
+      if (ctx.mode.is(Mode.Type))
+        typedAppliedTypeTree(cpy.AppliedTypeTree(tree)(op, l :: r :: Nil))
+      else if (ctx.mode.is(Mode.Pattern))
+        typedUnApply(cpy.Apply(tree)(op, l :: r :: Nil), pt)
+      else {
+        val app = typedApply(desugar.binop(l, op, r), pt)
+        if (untpd.isLeftAssoc(op.name)) app
+        else {
+          val defs = new mutable.ListBuffer[Tree]
+          def lift(app: Tree): Tree = (app: @unchecked) match {
+            case Apply(fn, args) =>
+              if (app.tpe.isError) app
+              else tpd.cpy.Apply(app)(fn, LiftImpure.liftArgs(defs, fn.tpe, args))
+            case Assign(lhs, rhs) =>
+              tpd.cpy.Assign(app)(lhs, lift(rhs))
+            case Block(stats, expr) =>
+              tpd.cpy.Block(app)(stats, lift(expr))
+          }
+          wrapDefs(defs, lift(app))
+        }
       }
-      wrapDefs(defs, lift(app))
-    }
+    checkValidInfix(tree, result.symbol)
+    result
   }
 
   /** Translate tuples of all arities */
@@ -2129,7 +2140,7 @@ class Typer extends Namer
           case tree: untpd.UnApply => typedUnApply(tree, pt)
           case tree: untpd.Tuple => typedTuple(tree, pt)
           case tree: untpd.DependentTypeTree => typed(untpd.TypeTree().withSpan(tree.span), pt)
-          case tree: untpd.InfixOp if ctx.mode.isExpr => typedInfixOp(tree, pt)
+          case tree: untpd.InfixOp => typedInfixOp(tree, pt)
           case tree @ untpd.PostfixOp(qual, Ident(nme.WILDCARD)) => typedAsFunction(tree, pt)
           case untpd.EmptyTree => tpd.EmptyTree
           case tree: untpd.Quote => typedQuote(tree, pt)

tests/neg-custom-args/infix.scala

@@ -3,6 +3,8 @@ import scala.annotation.infix
 class C {
   @infix def op(x: Int): Int = ???
   def meth(x: Int): Int = ???
+  def matching(x: Int => Int) = ???
+  def +(x: Int): Int = ???
 }
 
 val c = C()
@@ -12,4 +14,46 @@ def test() = {
 
   c.op(2)
   c meth 2    // error: should not be used as infix operator
+  c `meth` 2  // OK, sincd `meth` is backquoted
+  c + 3       // OK, since `+` is symbolic
+  1 to 2      // OK, since `to` is defined by Scala-2
+  c meth {    // OK, since `meth` is followed by `{...}`
+    3
+  }
+  c matching {    // OK, since `meth` is followed by `{...}`
+    case x => x
+  }
+
+  @infix class Or[X, Y]
+  class AndC[X, Y]
+  @infix type And[X, Y] = AndC[X, Y]
+  @infix type &&[X, Y] = AndC[X, Y]
+
+  class Map[X, Y]
+
+  val x1: Int Map String = ???     // error
+  val x2: Int Or String = ???      // OK since Or is declared `@infix`
+  val x3: Int AndC String = ???    // error
+  val x4: Int `AndC` String = ???  // OK
+  val x5: Int And String = ???     // OK
+  val x6: Int && String = ???
+
+  case class Pair[T](x: T, y: T)
+  @infix case class Q[T](x: T, y: T)
+
+  object PP {
+    @infix def unapply[T](x: Pair[T]): Option[(T, T)] = Some((x.x, x.y))
+  }
+
+  val p = Pair(1, 2)
+  val Pair(_, _) = p
+  val _ Pair _ = p   // error
+  val _ `Pair` _ = p // OK
+  val _ PP _ = p     // OK
+
+  val q = Q(1, 2)
+  val Q(_, _) = q
+  val _ Q _ = p   // OK
+
+
 }