Refine simple renaming imports and disallow them for exports

More test cases and fixes for simple renaming imports. Disallow
them for exports for now, since the primary use case of a renaming
export is not handled yet: lampepfl/dotty-feature-requests#148

Author: odersky

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

@@ -179,7 +179,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case _ => false
   }
 
-  /** Is this argument node of the form <expr> : _*, or is it a reference to
+  /** Is this argument node of the form <expr> *, or is it a reference to
    *  such an argument ? The latter case can happen when an argument is lifted.
    */
   def isWildcardStarArg(tree: Tree)(using Context): Boolean = unbind(tree) match {

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

@@ -1027,6 +1027,7 @@ object Trees {
     type Template = Trees.Template[T]
     type Import = Trees.Import[T]
     type Export = Trees.Export[T]
+    type ImportOrExport = Trees.ImportOrExport[T]
     type PackageDef = Trees.PackageDef[T]
     type Annotated = Trees.Annotated[T]
     type Thicket = Trees.Thicket[T]

compiler/src/dotty/tools/dotc/transform/FirstTransform.scala

@@ -150,7 +150,7 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   }
 
   override def transformOther(tree: Tree)(using Context): Tree = tree match {
-    case tree: ImportOrExport[_] => EmptyTree
+    case tree: ImportOrExport => EmptyTree
     case tree: NamedArg => transformAllDeep(tree.arg)
     case tree => if (tree.isType) toTypeTree(tree) else tree
   }

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

@@ -983,6 +983,10 @@ class Namer { typer: Typer =>
       def exportForwarders(exp: Export): List[tpd.MemberDef] = {
         val buf = new mutable.ListBuffer[tpd.MemberDef]
         val Export(expr, selectors) = exp
+        if expr.isEmpty then
+          report.error(em"Export selector must have prefix and `.`", exp.srcPos)
+          return Nil
+
         val path = typedAheadExpr(expr, AnySelectionProto)
         checkLegalExportPath(path, selectors)
         lazy val wildcardBound = importBound(selectors, isGiven = false)

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

@@ -2318,29 +2318,32 @@ class Typer extends Namer
     if imp.expr == untpd.EmptyTree then
       assert(imp.selectors.length == 1, imp)
       val from = imp.selectors.head.imported
-      val sel = typd(from, WildcardType)
-      sel.tpe.dealias match
-        case TermRef(prefix: SingletonType, _) =>
+      val sel = tryAlternatively
+          (typedIdent(from, WildcardType))
+          (typedIdent(cpy.Ident(from)(from.name.toTypeName), WildcardType))
+
+      sel.tpe match
+        case TermRef(prefix: SingletonType, _)  =>
+          singleton(prefix).withSpan(from.span)
+        case TypeRef(prefix: SingletonType, _)  =>
           singleton(prefix).withSpan(from.span)
         case _ =>
           errorTree(from,
             em"""Illegal import selector: $from
                 |The selector is not a member of an object or package.""")
     else typd(imp.expr, AnySelectionProto)
 
-  def typedImport(imp: untpd.Import, sym: Symbol)(using Context): Import = {
+  def typedImport(imp: untpd.Import, sym: Symbol)(using Context): Import =
     val expr1 = typedImportQualifier(imp, typedExpr)
     checkLegalImportPath(expr1)
     val selectors1 = typedSelectors(imp.selectors)
     assignType(cpy.Import(imp)(expr1, selectors1), sym)
-  }
 
-  def typedExport(exp: untpd.Export)(using Context): Export = {
+  def typedExport(exp: untpd.Export)(using Context): Export =
     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 =
     val pid1 = withMode(Mode.InPackageClauseName)(typedExpr(tree.pid, AnySelectionProto))

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -67,6 +67,7 @@ class CompilationTests {
 
     aggregateTests(
       compileFile("tests/rewrites/rewrites.scala", scala2CompatMode.and("-rewrite", "-indent")),
+      compileFile("tests/rewrites/rewrites3x.scala", defaultOptions.and("-rewrite", "-source", "3.1-migration")),
       compileFile("tests/rewrites/i8982.scala", defaultOptions.and("-indent", "-rewrite")),
       compileFile("tests/rewrites/i9632.scala", defaultOptions.and("-indent", "-rewrite"))
     ).checkRewrites()

tests/pos/renaming-imports.scala

@@ -7,3 +7,21 @@ import c.mutable as mut
 import mut.ArrayBuffer as Buf
 
 val y = Buf(1, 2, 3)
+
+object O:
+  type OString = String
+  def foo22(x: Int) = x
+
+class C:
+  import O.*
+  import foo22 as foo
+  import OString as OS
+  import scala.collection.Iterable
+  println(foo(22))
+  val s: OS = ""
+
+def test =
+  import C as CC
+  println(C().s)
+
+