record wildcard export dependencies in ClassSymbol

Author: bishabosha

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

@@ -370,6 +370,14 @@ object Symbols {
 
     private var myTree: TreeOrProvider = tpd.EmptyTree
 
+    private val myExportDependencies: util.HashSet[ClassSymbol] = util.HashSet()
+
+    def addExportDependency(dependency: ClassSymbol)(using Context): Unit =
+      if !ctx.isAfterTyper then
+        myExportDependencies += dependency
+
+    def exportDependencies: Iterator[ClassSymbol] = myExportDependencies.iterator
+
     /** If this is a top-level class and `-Yretain-trees` (or `-from-tasty`) is set.
       * Returns the TypeDef tree (possibly wrapped inside PackageDefs) for this class, otherwise EmptyTree.
       * This will force the info of the class.

compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala

@@ -328,13 +328,15 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
 
   private def addInheritanceDependencies(tree: Template)(using Context): Unit =
     if (tree.parents.nonEmpty) {
+      val cls = tree.symbol.owner.asClass
       val depContext =
-        if (tree.symbol.owner.isLocal) LocalDependencyByInheritance
+        if cls.isLocal then LocalDependencyByInheritance
         else DependencyByInheritance
       val from = resolveDependencySource
-      tree.parents.foreach { parent =>
+      for parent <- tree.parents do
         _dependencies += ClassDependency(from, parent.tpe.classSymbol, depContext)
-      }
+      for dep <- cls.exportDependencies if dep != cls do
+        _dependencies += ClassDependency(from, dep, depContext)
     }
 
   private def ignoreDependency(sym: Symbol)(using Context) =

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

@@ -54,6 +54,7 @@ class Namer { typer: Typer =>
   val TypedAhead      : Property.Key[tpd.Tree]            = new Property.Key
   val ExpandedTree    : Property.Key[untpd.Tree]          = new Property.Key
   val ExportForwarders: Property.Key[List[tpd.MemberDef]] = new Property.Key
+  val WildcardExport  : Property.Key[Unit]                = new Property.Key
   val SymOfTree       : Property.Key[Symbol]              = new Property.Key
   val Deriver         : Property.Key[typer.Deriver]       = new Property.Key
 
@@ -1037,17 +1038,21 @@ class Namer { typer: Typer =>
                 && mbr.matchesImportBound(if mbr.symbol.is(Given) then givenBound else wildcardBound)
               then addForwarder(alias, mbr, span)
 
-        def addForwarders(sels: List[untpd.ImportSelector], seen: List[TermName]): Unit = sels match
+        def addForwarders(sels: List[untpd.ImportSelector], seen: List[TermName]): Boolean = sels match
           case sel :: sels1 =>
             if sel.isWildcard then
               addWildcardForwarders(seen, sel.span)
+              true
             else
               if sel.rename != nme.WILDCARD then
                 addForwardersNamed(sel.name, sel.rename, sel.span)
               addForwarders(sels1, sel.name :: seen)
           case _ =>
+            false
 
-        addForwarders(selectors, Nil)
+        val hasWildcard = addForwarders(selectors, Nil)
+        if hasWildcard then
+          exp.pushAttachment(WildcardExport, ())
         val forwarders = buf.toList
         exp.pushAttachment(ExportForwarders, forwarders)
         forwarders

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

@@ -2247,6 +2247,12 @@ class Typer extends Namer
     assignType(cpy.Import(imp)(expr1, selectors1), sym)
   }
 
+  def typedExportExpr(tree: untpd.Export)(using Context): Tree = {
+    val expr1 = typedExpr(tree.expr, AnySelectionProto)
+    checkLegalImportPath(expr1)
+    expr1
+  }
+
   def typedPackageDef(tree: untpd.PackageDef)(using Context): Tree =
     val pid1 = withMode(Mode.InPackageClauseName)(typedExpr(tree.pid, AnySelectionProto))
     val pkg = pid1.symbol
@@ -2643,6 +2649,14 @@ class Typer extends Namer
       case Thicket(stats) :: rest =>
         traverse(stats ::: rest)
       case (stat: untpd.Export) :: rest =>
+        if stat.hasAttachment(WildcardExport) then
+          val expr = typedExportExpr(stat)
+          expr.tpe.classSymbol match
+            case cls if cls.isClass =>
+              ctx.owner.asClass.addExportDependency(cls.asClass)
+            case _ =>
+        end if
+
         buf ++= stat.attachmentOrElse(ExportForwarders, Nil)
           // no attachment can happen in case of cyclic references
         traverse(rest)