Imply @infix annotation for dotless extension methods

If an alphanumeric extension method is defined without a `.`,
add an @infix annotation.

Author: odersky

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

@@ -73,6 +73,10 @@ object NameOps {
     def isAnonymousFunctionName: Boolean = name.startsWith(str.ANON_FUN)
     def isUnapplyName: Boolean = name == nme.unapply || name == nme.unapplySeq
 
+    def isOperatorName: Boolean = name match
+      case name: SimpleName => name.exists(isOperatorPart)
+      case _ => false
+
     /** Is name a variable name? */
     def isVariableName: Boolean = testSimple { n =>
       n.length > 0 && {

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3197,24 +3197,32 @@ object Parsers {
         makeConstructor(Nil, vparamss, rhs).withMods(mods).setComment(in.getDocComment(start))
       }
       else {
+        var mods1 = addFlag(mods, Method)
+        var isInfix = false
         def extParamss() =
           try paramClause(0, prefix = true) :: Nil
           finally
+            mods1 = addFlag(mods, Extension)
             if in.token == DOT then in.nextToken()
-            else newLineOpt()
-        val (leadingTparams, leadingVparamss, flags) =
+            else
+              isInfix = true
+              newLineOpt()
+        val (leadingTparams, leadingVparamss) =
           if in.token == LBRACKET then
-            (typeParamClause(ParamOwner.Def), extParamss(), Method | Extension)
+            (typeParamClause(ParamOwner.Def), extParamss())
           else if in.token == LPAREN then
-            (Nil, extParamss(), Method | Extension)
+            (Nil, extParamss())
           else
-            (Nil, Nil, Method)
-        val mods1 = addFlag(mods, flags)
+            (Nil, Nil)
         val ident = termIdent()
         val name = ident.name.asTermName
+        if isInfix && !name.isOperatorName then
+          val infixAnnot = Apply(wrapNew(ref(defn.InfixAnnot.typeRef)), Nil)
+              .withSpan(Span(start, start))
+          mods1 = mods1.withAddedAnnotation(infixAnnot)
         val tparams =
           if in.token == LBRACKET then
-            if flags.is(Extension) then
+            if mods1.is(Extension) then
               if leadingTparams.isEmpty then
                 deprecationWarning("type parameters in extension methods should be written after `def`")
               else

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

@@ -277,7 +277,7 @@ object Checking {
   def checkValidOperator(sym: Symbol)(implicit ctx: Context): Unit =
     sym.name.toTermName match {
       case name: SimpleName
-      if name.exists(isOperatorPart)
+      if name.isOperatorName
          && !name.isSetterName
          && !name.isConstructorName
          && !sym.getAnnotation(defn.AlphaAnnot).isDefined
@@ -754,7 +754,7 @@ trait Checking {
         name.toTermName match {
           case name: SimpleName
           if !untpd.isBackquoted(id) &&
-             !name.exists(isOperatorPart) &&
+             !name.isOperatorName &&
              !isInfix(meth) &&
              !meth.maybeOwner.is(Scala2x) &&
              !infixOKSinceFollowedBy(tree.right) &&

tests/neg-custom-args/infix.scala

@@ -1,18 +1,27 @@
 // Compile with -strict -Xfatal-warnings -deprecation
 import scala.annotation.infix
-class C {
+class C:
   @infix def op(x: Int): Int = ???
   def meth(x: Int): Int = ???
   def matching(x: Int => Int) = ???
   def +(x: Int): Int = ???
-}
+
+object C:
+  given AnyRef:
+    def (x: C) iop (y: Int) = ???
+    def (x: C).mop (y: Int) = ???
+    def (x: C) ++ (y: Int) = ???
 
 val c = C()
 def test() = {
   c op 2
+  c iop 2
   c.meth(2)
+  c ++ 2
 
   c.op(2)
+  c.iop(2)
+  c mop 2     // error: should not be used as infix operator
   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