Refactorings

Move reusable code into SymDenotations and NameOps

Author: odersky

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

@@ -72,6 +72,7 @@ object NameOps {
     def isAnonymousClassName: Boolean = name.startsWith(str.ANON_CLASS)
     def isAnonymousFunctionName: Boolean = name.startsWith(str.ANON_FUN)
     def isUnapplyName: Boolean = name == nme.unapply || name == nme.unapplySeq
+    def isRightAssocOperatorName: Boolean = name.lastPart.last == ':'
 
     def isOperatorName: Boolean = name match
       case name: SimpleName => name.exists(isOperatorPart)

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

@@ -325,6 +325,18 @@ object SymDenotations {
       else recurWithParamss(info, rawParamss)
     end paramSymss
 
+    /** The extension parameter of this extension method
+     *  @pre this symbol is an extension method
+     */
+    final def extensionParam(using Context): Symbol =
+      def leadParam(paramss: List[List[Symbol]]): Symbol = paramss match
+        case (param :: _) :: paramss1 if param.isType => leadParam(paramss1)
+        case _ :: (snd :: Nil) :: _ if name.isRightAssocOperatorName => snd
+        case (fst :: Nil) :: _ => fst
+        case _ => NoSymbol
+      assert(isAllOf(ExtensionMethod))
+      leadParam(rawParamss)
+
     /** The denotation is completed: info is not a lazy type and attributes have defined values */
     final def isCompleted: Boolean = !myInfo.isInstanceOf[LazyType]
 

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

@@ -452,16 +452,9 @@ class Typer extends Namer
      */
     def extensionMethodSelect: untpd.Tree =
       val xmethod = ctx.owner.enclosingExtensionMethod
-      def leadingParam(paramss: List[List[Symbol]]): Symbol = paramss match
-        case (param :: _) :: paramss1 if param.isType => leadingParam(paramss1)
-        case _ :: (snd :: Nil) :: _ if !isLeftAssoc(xmethod.name) => snd
-        case (fst :: Nil) :: _ => fst
-        case _ => NoSymbol
       val qualifier =
-        if xmethod.exists then
-          untpd.ref(leadingParam(xmethod.rawParamss).termRef)
-        else
-          untpd.This(untpd.EmptyTypeIdent)
+        if xmethod.exists then untpd.ref(xmethod.extensionParam.termRef)
+        else untpd.This(untpd.EmptyTypeIdent)
       untpd.cpy.Select(tree)(qualifier, name)
 
     val rawType = {