Make export of default getters work also with named and given exports

Author: odersky

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

@@ -1070,6 +1070,26 @@ 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")
+
       /** 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.
         */
@@ -1125,20 +1145,18 @@ class Namer { typer: Typer =>
           forwarder.info = avoidPrivateLeaks(forwarder)
           forwarder.addAnnotations(sym.annotations)
 
-          val forwarderDef =
-            if (forwarder.isType) tpd.TypeDef(forwarder.asType)
-            else {
-              import tpd._
-              val ref = path.select(sym.asTerm)
-              val ddef = tpd.DefDef(forwarder.asTerm, prefss =>
-                  ref.appliedToArgss(adaptForwarderParams(Nil, sym.info, prefss))
-              )
-              if forwarder.isInlineMethod then
-                PrepareInlineable.registerInlineInfo(forwarder, ddef.rhs)
-              ddef
-            }
-
-          buf += forwarderDef.withSpan(span)
+          if forwarder.isType then
+            buf += tpd.TypeDef(forwarder.asType).withSpan(span)
+          else
+            import tpd._
+            val ref = path.select(sym.asTerm)
+            val ddef = tpd.DefDef(forwarder.asTerm, prefss =>
+                ref.appliedToArgss(adaptForwarderParams(Nil, sym.info, prefss)))
+            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)
       end addForwarder
 
       def addForwardersNamed(name: TermName, alias: TermName, span: Span): Unit =
@@ -1162,11 +1180,15 @@ class Namer { typer: Typer =>
         def isCaseClassSynthesized(mbr: Symbol) =
           fromCaseClass && defn.caseClassSynthesized.contains(mbr)
         for mbr <- path.tpe.membersBasedOnFlags(required = EmptyFlags, excluded = PrivateOrSynthetic) do
-          if !mbr.symbol.isSuperAccessor && !isCaseClassSynthesized(mbr.symbol) then
-            // Scala 2 superaccessors have neither Synthetic nor Artfact set, so we
-            // need to filter them out here (by contrast, Scala 3 superaccessors are Artifacts)
-            // Symbols from base traits of case classes that will get synthesized implementations
-            // at PostTyper are also excluded.
+          if !mbr.symbol.isSuperAccessor
+              // Scala 2 superaccessors have neither Synthetic nor Artfact set, so we
+              // need to filter them out here (by contrast, Scala 3 superaccessors are Artifacts)
+              // Symbols from base traits of case classes that will get synthesized implementations
+              // at PostTyper are also excluded.
+            && !isCaseClassSynthesized(mbr.symbol)
+            && !mbr.symbol.name.is(DefaultGetterName)
+              // default getters are exported with the members they belong to
+          then
             val alias = mbr.name.toTermName
             if mbr.symbol.is(Given) then
               if !seen.contains(alias) && mbr.matchesImportBound(givenBound) then

tests/run/i14020.check

@@ -1,3 +1,7 @@
 Hello you
 Hello John
 Hello you
+Hello you
+Hello John
+Hello you
+bark: Woof!

tests/run/i14020.scala

@@ -5,9 +5,31 @@ class B:
   val a = A()
   export a.*
 
+class C:
+  val a = A()
+  export a.greeting
+
 @main def Test =
   val b = B()
 
   println(b.a.greeting())      // works
   println(b.greeting("John"))  // works
-  println(b.greeting())        // nope !
+  println(b.greeting())        // nope !
+
+  val c = C()
+
+  println(c.a.greeting())      // works
+  println(c.greeting("John"))  // works
+  println(c.greeting())        // nope !
+
+  val w = Wolf()
+  import w.given
+
+  println(summon[String]) // error: I found: w.bark(/* missing */summon[String])
+
+class Dog:
+  given bark(using msg: String = "Woof!"): String = s"bark: $msg"
+
+class Wolf:
+  private val dog = Dog()
+  export dog.given // needs to be `export dog.{given, *}` to export the default arguments