Relax infix criterion

 - Only checked under -strict
 - Not checked for symbols coming from Scala-2
 - Infix alphanumeric is OK when followed by `{`

Author: odersky

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

@@ -660,18 +660,29 @@ trait Checking {
           i"Use of implicit conversion ${conv.showLocated}", NoSymbol, posd.sourcePos)
     }
 
+  private def infixOKSinceFollowedBy(tree: untpd.Tree): Boolean = tree match {
+    case _: untpd.Block | _: untpd.Match => true
+    case _ => false
+  }
+
   /** 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 =
     tree.op match {
+      case _: untpd.BackquotedIdent =>
+        ()
       case Ident(name: SimpleName)
-      if !name.exists(isOperatorPart) && !app.symbol.hasAnnotation(defn.InfixAnnot) && false =>
+      if !name.exists(isOperatorPart) &&
+         !app.symbol.hasAnnotation(defn.InfixAnnot) &&
+         !app.symbol.maybeOwner.is(Scala2x) &&
+         !infixOKSinceFollowedBy(tree.right) &&
+         ctx.settings.strict.value =>
         ctx.deprecationWarning(
           i"""alphanumeric method $name is not declared @infix; should not be used as infix operator.
-             |The operation can be rewritten automatically under -migration -rewrite""",
+             |The operation can be rewritten automatically to `$name` under -deprecation -rewrite""",
           tree.op.sourcePos)
-        if (ctx.scala2Mode) {
+        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), "`")
         }

docs/docs/reference/changed-features/operators.md

@@ -78,8 +78,17 @@ s1 difference s2    // gives a deprecation warning
 s1 * s2             // OK
 s1.*(s2)            // also OK, but unusual
 ```
-Infix operations involving alphanumeric operators that do not carry @infix annotations are deprecated. Infix operations involving symbolic operators are always allowed, so `@infix` is redundant for methods with symbolic names. Infix operations are also allowed
-if an alphanumeric operator name is given in backticks (as in the third call of `difference` above).
+Infix operations involving alphanumeric operators are deprecated, unless
+one of the following conditions holds:
+
+ - the operator definition carries an `@infix` annotation, or
+ - the operator was compiled with Scala 2, or
+ - the operator is followed by an opening brace.
+
+An alphanumeric operator is an operator consisting entirely of letters, digits, the `$` and `_` characters, or
+any unicode character `c` for which `java.lang.Character.isIdentifierPart(c)` returns `true`.
+
+Infix operations involving symbolic operators are always allowed, so `@infix` is redundant for methods with symbolic names.
 
 The @infix annotation can also be given to a type:
 ```
@@ -116,3 +125,5 @@ The purpose of the `@infix` annotation is to achieve consistency across a code b
 
     can be applied using infix syntax, i.e. `A op B`.
 
+ 5. To smooth migration to Scala 3.0, alphanumeric operations will only be deprecated from Scala 3.1 onwards,
+or if the `-strict` option is given in Dotty/Scala 3.