restrict export wildcard from package

Author: bishabosha

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

@@ -719,12 +719,29 @@ trait Checking {
     recur(pat, pt)
   }
 
-  /** Check that `path` is a legal prefix for an import or export clause */
-  def checkLegalImportPath(path: Tree)(using Context): Unit = {
-    checkStable(path.tpe, path.srcPos, "import prefix")
+  private def checkLegalImportOrExportPath(path: Tree, kind: String)(using Context): Unit = {
+    checkStable(path.tpe, path.srcPos, kind)
     if (!ctx.isAfterTyper) Checking.checkRealizable(path.tpe, path.srcPos)
   }
 
+  /** Check that `path` is a legal prefix for an import clause */
+  def checkLegalImportPath(path: Tree)(using Context): Unit = {
+    checkLegalImportOrExportPath(path, "import prefix")
+  }
+
+  /** Check that `path` is a legal prefix for an export clause */
+  def checkLegalExportPath(path: Tree, selectors: List[untpd.ImportSelector])(using Context): Unit =
+    checkLegalImportOrExportPath(path, "export prefix")
+    if
+      selectors.exists(_.isWildcard)
+      && path.tpe.classSymbol.is(PackageClass)
+    then
+      // we restrict wildcard export from package as incremental compilation does not yet
+      // register a dependency on "all members of a package" - see https://github.com/sbt/zinc/issues/226
+      report.error(
+        em"Implementation restriction: ${path.tpe.classSymbol} is not a valid prefix " +
+          "for a wildcard export, as it is a package.", path.srcPos)
+
  /**  Check that `tp` is a class type.
   *   Also, if `traitReq` is true, check that `tp` is a trait.
   *   Also, if `stablePrefixReq` is true and phase is not after RefChecks,

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

@@ -945,7 +945,7 @@ class Namer { typer: Typer =>
         val buf = new mutable.ListBuffer[tpd.MemberDef]
         val Export(expr, selectors) = exp
         val path = typedAheadExpr(expr, AnySelectionProto)
-        checkLegalImportPath(path)
+        checkLegalExportPath(path, selectors)
         lazy val wildcardBound = importBound(selectors, isGiven = false)
         lazy val givenBound = importBound(selectors, isGiven = true)
 

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

@@ -2235,29 +2235,26 @@ class Typer extends Namer
   def localDummy(cls: ClassSymbol, impl: untpd.Template)(using Context): Symbol =
     newLocalDummy(cls, impl.span)
 
-  inline def typedImportOrExport[T <: ImportOrExport[Untyped]](imp: T)(
-    inline mkTree: (Tree, List[untpd.ImportSelector]) => imp.ThisTree[Type])(using Context): imp.ThisTree[Type] = {
-    val expr1 = typedExpr(imp.expr, AnySelectionProto)
-    checkLegalImportPath(expr1)
-    val selectors1: List[untpd.ImportSelector] = imp.selectors.mapConserve { sel =>
+  inline private def typedSelectors(selectors: List[untpd.ImportSelector])(using Context): List[untpd.ImportSelector] =
+    selectors.mapConserve { sel =>
       if sel.bound.isEmpty then sel
       else cpy.ImportSelector(sel)(
         sel.imported, sel.renamed, untpd.TypedSplice(typedType(sel.bound)))
         .asInstanceOf[untpd.ImportSelector]
     }
-    mkTree(expr1, selectors1)
-  }
 
   def typedImport(imp: untpd.Import, sym: Symbol)(using Context): Import = {
-    typedImportOrExport(imp)((expr1, selectors1) =>
-      assignType(cpy.Import(imp)(expr1, selectors1), sym)
-    )
+    val expr1 = typedExpr(imp.expr, AnySelectionProto)
+    checkLegalImportPath(expr1)
+    val selectors1 = typedSelectors(imp.selectors)
+    assignType(cpy.Import(imp)(expr1, selectors1), sym)
   }
 
   def typedExport(exp: untpd.Export)(using Context): Export = {
-    typedImportOrExport(exp)((expr1, selectors1) =>
-      assignType(cpy.Export(exp)(expr1, selectors1))
-    )
+    val expr1 = typedExpr(exp.expr, AnySelectionProto)
+    // already called `checkLegalExportPath` in Namer
+    val selectors1 = typedSelectors(exp.selectors)
+    assignType(cpy.Export(exp)(expr1, selectors1))
   }
 
   def typedPackageDef(tree: untpd.PackageDef)(using Context): Tree =

tests/neg/package-export/defaults.scala

@@ -0,0 +1,3 @@
+package defaults
+
+given numerics.Ring[Int] = ???

tests/neg/package-export/enums.scala

@@ -0,0 +1,5 @@
+package enums
+
+def enumOrdinal[T](t: T): Int = t match
+  case t: reflect.Enum => t.ordinal
+  case t               => -1

tests/neg/package-export/numerics.scala

@@ -0,0 +1,3 @@
+package numerics
+
+trait Ring[T]

tests/neg/package-export/package.scala

@@ -0,0 +1,7 @@
+package mylib
+
+export numerics._ // error: package numerics is not a valid prefix for a wildcard export...
+
+export defaults.{given Ring[Int]} // error: package defaults is not a valid prefix for a wildcard export...
+
+export enums.enumOrdinal // ok, enums is a package but export is not wildcard