Simplify

Author: odersky

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

@@ -1070,25 +1070,16 @@ class Namer { typer: Typer =>
         else Yes
       }
 
-      def defaultGetters(sym: TermSymbol): List[Symbol] =
-        def recur(params: List[Symbol], paramss: List[List[Symbol]], n: Int): List[Symbol] =
-          params match
-            case param :: params1 =>
-              def otherGetters =
-                recur(params1, paramss, if param.isType then n else n + 1)
-              if param.is(HasDefault) then
-                val getterName = DefaultGetterName(sym.name, n)
-                val getter = path.tpe.member(DefaultGetterName(sym.name, n)).symbol
-                assert(getter.exists, i"$path does not have a default getter named $getterName")
-                getter :: otherGetters
-              else
-                otherGetters
-            case Nil =>
-              paramss match
-                case params1 :: paramss1 => recur(params1, paramss1, n)
-                case Nil => Nil
-        recur(Nil, sym.paramSymss, 0)
-          .showing(i"default getters of $sym, ${sym.paramSymss.nestedMap(_.flagsString)} = $result")
+      def foreachDefaultGetterOf(sym: TermSymbol, op: TermSymbol => Unit): Unit =
+        var n = 0
+        for params <- sym.paramSymss; param <- params do
+          if param.isTerm then
+            if param.is(HasDefault) then
+              val getterName = DefaultGetterName(sym.name, n)
+              val getter = path.tpe.member(DefaultGetterName(sym.name, n)).symbol
+              assert(getter.exists, i"$path does not have a default getter named $getterName")
+              op(getter.asTerm)
+            n += 1
 
       /** Add a forwarder with name `alias` or its type name equivalent to `mbr`,
         *  provided `mbr` is accessible and of the right implicit/non-implicit kind.
@@ -1112,6 +1103,7 @@ class Namer { typer: Typer =>
 
         if canForward(mbr) == CanForward.Yes then
           val sym = mbr.symbol
+          val hasDefaults = sym.hasDefaultParams // compute here to ensure HasDefaultParams and NoDefaultParams flags are set
           val forwarder =
             if mbr.isType then
               val forwarderName = checkNoConflict(alias.toTypeName, isPrivate = false, span)
@@ -1136,7 +1128,6 @@ class Namer { typer: Typer =>
                   (StableRealizable, ExprType(path.tpe.select(sym)))
                 else
                   (EmptyFlags, mbr.info.ensureMethodic)
-              sym.hasDefaultParams // ensure HasDefaultParams and NoDefaultParams flags are set
               var mbrFlags = Exported | Method | Final | maybeStable | sym.flags & RetainedExportFlags
               if sym.is(ExtensionMethod) then mbrFlags |= ExtensionMethod
               val forwarderName = checkNoConflict(alias, isPrivate = false, span)
@@ -1155,8 +1146,9 @@ class Namer { typer: Typer =>
             if forwarder.isInlineMethod then
               PrepareInlineable.registerInlineInfo(forwarder, ddef.rhs)
             buf += ddef.withSpan(span)
-            for getter <- defaultGetters(sym.asTerm) do
-              addForwarder(getter.name.asTermName, getter, span)
+            if hasDefaults then
+              foreachDefaultGetterOf(sym.asTerm,
+                getter => addForwarder(getter.name.asTermName, getter, span))
       end addForwarder
 
       def addForwardersNamed(name: TermName, alias: TermName, span: Span): Unit =