Merge pull request #8308 from dotty-staging/change-infix-x

Imply @infix annotation for dotless extension methods

Author: odersky

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

@@ -445,6 +445,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   def rootDot(name: Name)(implicit src: SourceFile): Select = Select(Ident(nme.ROOTPKG), name)
   def scalaDot(name: Name)(implicit src: SourceFile): Select = Select(rootDot(nme.scala_), name)
+  def scalaAnnotationDot(name: Name)(using SourceFile): Select = Select(scalaDot(nme.annotation), name)
   def scalaUnit(implicit src: SourceFile): Select = scalaDot(tpnme.Unit)
   def scalaAny(implicit src: SourceFile): Select = scalaDot(tpnme.Any)
   def javaDotLangDot(name: Name)(implicit src: SourceFile): Select = Select(Select(Ident(nme.java), nme.lang), name)

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/core/StdNames.scala

@@ -486,6 +486,7 @@ object StdNames {
     val implicitly: N           = "implicitly"
     val in: N                   = "in"
     val inline: N               = "inline"
+    val infix: N                = "infix"
     val info: N                 = "info"
     val inlinedEquals: N        = "inlinedEquals"
     val internal: N             = "internal"

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

@@ -3205,24 +3205,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(scalaAnnotationDot(tpnme.infix)), 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) &&

docs/docs/reference/contextual/extension-methods-new.md

@@ -3,15 +3,12 @@ layout: doc-page
 title: "Extension Methods"
 ---
 
-**Note:** The syntax of extension methods is about to change. Here is the
-[doc page with the new syntax](./extension-methods-new.html), supported from Dotty 0.22 onwards.
-
 Extension methods allow one to add methods to a type after the type is defined. Example:
 
 ```scala
 case class Circle(x: Double, y: Double, radius: Double)
 
-def (c: Circle) circumference: Double = c.radius * math.Pi * 2
+def (c: Circle).circumference: Double = c.radius * math.Pi * 2
 ```
 
 Like regular methods, extension methods can be invoked with infix `.`:
@@ -72,8 +69,8 @@ Assume a selection `e.m[Ts]` where `m` is not a member of `e`, where the type ar
 and where `T` is the expected type. The following two rewritings are tried in order:
 
  1. The selection is rewritten to `m[Ts](e)`.
- 2. If the first rewriting does not typecheck with expected type `T`, and there is a given `g`
-    in either the current scope or in the context scope of `T` such that `g` defines an extension
+ 2. If the first rewriting does not typecheck with expected type `T`, and there is a given instance `g`
+    in either the current scope or in the context scope of `T`, and `g` defines an extension
     method named `m`, then selection is expanded to `g.m[Ts](e)`.
     This second rewriting is attempted at the time where the compiler also tries an implicit conversion
     from `T` to a type containing `m`. If there is more than one way of rewriting, an ambiguity error results.
@@ -84,8 +81,7 @@ So `circle.circumference` translates to `CircleOps.circumference(circle)`, provi
 ### Operators
 
 The extension method syntax also applies to the definition of operators.
-In this case it is allowed and preferable to omit the period between the leading parameter list
-and the operator. In each case the definition syntax mirrors the way the operator is applied.
+This case is indicated by omitting the period between the leading parameter list and the operator. In each case the definition syntax mirrors the way the operator is applied.
 Examples:
 ```scala
 def (x: String) < (y: String) = ...
@@ -96,6 +92,8 @@ def (x: Number) min (y: Number) = ...
 1 +: List(2, 3)
 x min 3
 ```
+For alphanumeric extension operators like `min` an `@infix` annotation is implied.
+
 The three definitions above translate to
 ```scala
 def < (x: String)(y: String) = ...
@@ -106,6 +104,7 @@ Note the swap of the two parameters `x` and `xs` when translating
 the right-binding operator `+:` to an extension method. This is analogous
 to the implementation of right binding operators as normal methods.
 
+
 ### Generic Extensions
 
 The `StringSeqOps` examples extended a specific instance of a generic type. It is also possible to extend a generic type by adding type parameters to an extension method. Examples:
@@ -170,15 +169,14 @@ given extension_largest_List_T as AnyRef {
 ### Syntax
 
 Here are the syntax changes for extension methods and collective extensions relative
-to the [current syntax](../../internals/syntax.md). `extension` is a soft keyword, recognized only
-in tandem with `on`. It can be used as an identifier everywhere else.
+to the [current syntax](../../internals/syntax.md). `extension` is a soft keyword, recognized only in tandem with `on`. It can be used as an identifier everywhere else.
+
 ```
 DefSig            ::=  ...
                     |  ExtParamClause [nl] [‘.’] id DefParamClauses
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
 TmplDef           ::=  ...
                     |  ‘extension’ ExtensionDef
-ExtensionDef      ::=  [id] ‘on’ ExtParamClause {GivenParamClause} ‘with’ ExtMethods
+ExtensionDef      ::=  [id] ‘on’ ExtParamClause {GivenParamClause} ExtMethods
 ExtMethods        ::=  ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 ```
-

docs/docs/reference/contextual/extension-methods.md

@@ -11,7 +11,7 @@ with canonical implementations defined by given instances. Here are some example
 
 ```scala
 trait SemiGroup[T] {
-  @infix def (x: T) combine (y: T): T
+  def (x: T) combine (y: T): T
 }
 
 trait Monoid[T] extends SemiGroup[T] {

docs/docs/reference/contextual/typeclasses.md

@@ -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

tests/neg-custom-args/infix.scala

@@ -11,7 +11,7 @@ package O {
         protected[A] def f: Int = 0
         def g: Int = 0
         def g1(t: Int): Int = 0
-        def (c: D.this.C) g1: Int = 0
+        @_root_.scala.annotation.infix() def (c: D.this.C) g1: Int = 0
       }
       private[D] class E() extends Object() {}
       private[this] class F() extends Object() {}