Migration warning for non-unary symbolic operators

Under Scala-2 mode, issue a migration warning for a symbolic method that is
not unary.

Also: Two more tests updated to new infix operator regime.

Author: odersky

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

@@ -87,8 +87,10 @@ object NameOps {
       }
     }
 
-    def isOpName = name match {
-      case name: SimpleName => NameTransformer.encode(name) != name
+    /** Is name an operator name that does not start with a letter or `_` or `$`? */
+    def isSymbolic = name match {
+      case name: SimpleName =>
+        !Chars.isIdentifierStart(name.head) && NameTransformer.encode(name) != name
       case _ => false
     }
 

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

@@ -850,6 +850,29 @@ trait Checking {
           checkEnumCaseRefsLegal(stat, enumContext)
     stats
   }
+
+  /** `tp` refers to a method with exactly one parameter in its first parameter list.
+   *  If `tp` is overloaded, all alternatives are unary in that sense.
+   */
+  def isUnary(tp: Type)(implicit ctx: Context): Boolean = tp match {
+    case tp: MethodicType =>
+      tp.firstParamTypes match {
+        case ptype :: Nil => !ptype.isRepeatedParam
+        case _ => false
+      }
+    case tp: TermRef =>
+      tp.denot.alternatives.forall(alt => isUnary(alt.info))
+    case _ =>
+      false
+  }
+
+  /** Under Scala-2 mode, issue a migration warning for a symbolic method that is
+   *  not unary.
+   */
+  def checkSymbolicUnary(sym: Symbol)(implicit ctx: Context): Unit =
+    if (sym.name.isSymbolic && !isUnary(sym.info) && ctx.scala2Mode)
+      ctx.migrationWarning(i"""symbolic operator `${sym.name}` should take exactly one parameter,
+                              |otherwise it cannot be used in infix position.""", sym.pos)
 }
 
 trait ReChecking extends Checking {
@@ -877,4 +900,5 @@ trait NoChecking extends ReChecking {
   override def checkCaseInheritance(parentSym: Symbol, caseCls: ClassSymbol, pos: Position)(implicit ctx: Context) = ()
   override def checkNoForwardDependencies(vparams: List[ValDef])(implicit ctx: Context): Unit = ()
   override def checkMembersOK(tp: Type, pos: Position)(implicit ctx: Context): Type = tp
+  override def checkSymbolicUnary(sym: Symbol)(implicit ctx: Context): Unit = ()
 }

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

@@ -1434,6 +1434,8 @@ class Typer extends Namer
       for (param <- tparams1 ::: vparamss1.flatten)
         checkRefsLegal(param, sym.owner, (name, sym) => sym.is(TypeParam), "secondary constructor")
 
+    checkSymbolicUnary(sym)
+
     assignType(cpy.DefDef(ddef)(name, tparams1, vparamss1, tpt1, rhs1), sym)
       //todo: make sure dependent method types do not depend on implicits or by-name params
   }

tests/pos/Map.scala

@@ -176,7 +176,7 @@ object Map extends ImmutableMapFactory[Map] {
       else if (key == key2) new Map4(key1, value1, key2, value, key3, value3, key4, value4)
       else if (key == key3) new Map4(key1, value1, key2, value2, key3, value, key4, value4)
       else if (key == key4) new Map4(key1, value1, key2, value2, key3, value3, key4, value)
-      else new HashMap + ((key1, value1), (key2, value2), (key3, value3), (key4, value4), (key, value))
+      else HashMap((key1, value1), (key2, value2), (key3, value3), (key4, value4), (key, value))
     def + [B1 >: B](kv: (A, B1)): Map[A, B1] = updated(kv._1, kv._2)
     def - (key: A): Map[A, B] =
       if (key == key1)      new Map3(key2, value2, key3, value3, key4, value4)

tests/run/iterators.scala

@@ -57,8 +57,8 @@ object Test {
   def check_drop: Int = {
     val it1 = Iterator.from(0)
     val it2 = it1 map { 2 * _ }
-    val n1 = it1 drop 2 next()
-    val n2 = it2 drop 2 next();
+    val n1 = (it1 drop 2) .next()
+    val n2 = (it2 drop 2) .next();
     n1 + n2
   }