Refactor extMethod

Author: som-snytt

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

@@ -9,7 +9,7 @@ import Decorators.*
 import Annotations.Annotation
 import NameKinds.{UniqueName, ContextBoundParamName, ContextFunctionParamName, DefaultGetterName, WildcardParamName}
 import typer.{Namer, Checking}
-import util.{Property, SourceFile, SourcePosition, SrcPos, Chars}
+import util.{Chars, NoSourcePosition, Property, SourceFile, SourcePosition, SrcPos}
 import config.{Feature, Config}
 import config.Feature.{sourceVersion, migrateTo3, enabled}
 import config.SourceVersion.*
@@ -1185,55 +1185,59 @@ object desugar {
   }
 
   def extMethod(mdef: DefDef, extParamss: List[ParamClause])(using Context): DefDef =
+    def finish(problem: String = "", pos: SrcPos = NoSourcePosition) =
+      if !problem.isEmpty then
+        report.error(em"right-associative extension method $problem", pos)
+      extParamss ++ mdef.paramss
+    def rightAssocParams =
+      val (rightTyParams, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
+
+      paramss match
+      case rightParam :: paramss1 => // `rightParam` must have a single parameter and without `given` flag
+        rightParam match
+        case ValDefs(vparam :: Nil) =>
+          if !vparam.mods.is(Given) then
+            // we merge the extension parameters with the method parameters,
+            // swapping the operator arguments:
+            // e.g.
+            //   extension [A](using B)(c: C)(using D)
+            //     def %:[E](f: F)(g: G)(using H): Res = ???
+            // will be encoded as
+            //   def %:[A](using B)[E](f: F)(c: C)(using D)(g: G)(using H): Res = ???
+            //
+            // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
+            val (leftTyParamsAndLeadingUsing, leftParamAndTrailingUsing) = extParamss.span(isUsingOrTypeParamClause)
+
+            val names = (for ps <- mdef.paramss; p <- ps yield p.name).toSet[Name]
+
+            val tt = new untpd.UntypedTreeTraverser:
+              def traverse(tree: Tree)(using Context): Unit = tree match
+                case tree: Ident if names.contains(tree.name) =>
+                  finish(s"cannot have a forward reference to ${tree.name}", tree.srcPos)
+                case _ => traverseChildren(tree)
+
+            for ts <- leftParamAndTrailingUsing; t <- ts do
+              tt.traverse(t)
+
+            leftTyParamsAndLeadingUsing ::: rightTyParams ::: rightParam :: leftParamAndTrailingUsing ::: paramss1
+          else
+            finish("cannot start with using clause", mdef.srcPos)
+        case _ =>
+          finish("must start with a single parameter", mdef.srcPos)
+      case _ =>
+        // no value parameters, so not an infix operator.
+        finish()
+    end rightAssocParams
+
     cpy.DefDef(mdef)(
       name = normalizeName(mdef, mdef.tpt).asTermName,
       paramss =
         if mdef.name.isRightAssocOperatorName then
-          val (rightTyParams, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
-
-          paramss match
-            case rightParam :: paramss1 => // `rightParam` must have a single parameter and without `given` flag
-
-              def badRightAssoc(problem: String, pos: SrcPos) =
-                report.error(em"right-associative extension method $problem", pos)
-                extParamss ++ mdef.paramss
-
-              rightParam match
-                case ValDefs(vparam :: Nil) =>
-                  if !vparam.mods.is(Given) then
-                    // we merge the extension parameters with the method parameters,
-                    // swapping the operator arguments:
-                    // e.g.
-                    //   extension [A](using B)(c: C)(using D)
-                    //     def %:[E](f: F)(g: G)(using H): Res = ???
-                    // will be encoded as
-                    //   def %:[A](using B)[E](f: F)(c: C)(using D)(g: G)(using H): Res = ???
-                    //
-                    // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
-                    val (leftTyParamsAndLeadingUsing, leftParamAndTrailingUsing) = extParamss.span(isUsingOrTypeParamClause)
-
-                    val names = (for ps <- mdef.paramss; p <- ps yield p.name).toSet[Name]
-
-                    val tt = new untpd.UntypedTreeTraverser:
-                      def traverse(tree: Tree)(using Context): Unit = tree match
-                        case tree: Ident if names.contains(tree.name) =>
-                          badRightAssoc(s"cannot have a forward reference to ${tree.name}", tree.srcPos)
-                        case _ => traverseChildren(tree)
-
-                    for ts <- leftParamAndTrailingUsing; t <- ts do
-                      tt.traverse(t)
-
-                    leftTyParamsAndLeadingUsing ::: rightTyParams ::: rightParam :: leftParamAndTrailingUsing ::: paramss1
-                  else
-                    badRightAssoc("cannot start with using clause", mdef.srcPos)
-                case _ =>
-                  badRightAssoc("must start with a single parameter", mdef.srcPos)
-            case _ =>
-              // no value parameters, so not an infix operator.
-              extParamss ++ mdef.paramss
+          rightAssocParams
         else
-          extParamss ++ mdef.paramss
+          finish()
     ).withMods(mdef.mods | ExtensionMethod)
+  end extMethod
 
   /** Transform extension construct to list of extension methods */
   def extMethods(ext: ExtMethods)(using Context): Tree = flatTree {