Merge pull request #11244 from dotty-staging/change-imports

Allow new import syntax

Author: odersky

bench/tests/Vector.scala

@@ -12,7 +12,7 @@ package immutable
 
 import scala.annotation.unchecked.uncheckedVariance
 import scala.compat.Platform
-import scala.collection.generic._
+import scala.collection.generic.*
 import scala.collection.mutable.Builder
 import compiletime.uninitialized
 

bench/tests/power-macro/PowerInlined-1.scala

@@ -1,5 +1,5 @@
 object PowerInlined {
-  import PowerMacro._
+  import PowerMacro.*
 
   power(1, 5.0) // 1 quotes to unpickle
 }

bench/tests/power-macro/PowerInlined.scala

@@ -1,5 +1,5 @@
 object PowerInlined {
-  import PowerMacro._
+  import PowerMacro.*
 
   power(1, 5.0) // 1 quotes to unpickle
 }

community-build/community-projects/munit

@@ -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/TreeInfo.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/ast/Trees.scala

@@ -3066,8 +3066,8 @@ object Parsers {
 
     type ImportConstr = (Tree, List[ImportSelector]) => Tree
 
-    /** Import  ::= `import' [`given'] [ImportExpr {`,' ImportExpr}
-     *  Export  ::= `export' [`given'] [ImportExpr {`,' ImportExpr}
+    /** Import  ::= `import' ImportExpr {‘,’ ImportExpr}
+     *  Export  ::= `export' ImportExpr {‘,’ ImportExpr}
      */
     def importClause(leading: Token, mkTree: ImportConstr): List[Tree] = {
       val offset = accept(leading)
@@ -3097,48 +3097,62 @@ object Parsers {
             ctx.compilationUnit.sourceVersion = Some(SourceVersion.valueOf(imported.toString))
       Import(tree, selectors)
 
-    /**  ImportExpr ::= SimpleRef {‘.’ id} ‘.’ ImportSpec
-     *   ImportSpec  ::=  id
-     *                 | ‘_’
-     *                 | ‘given’
-     *                 | ‘{’ ImportSelectors) ‘}’
-     */
-    def importExpr(mkTree: ImportConstr): () => Tree = {
-
-      /** '_' */
-      def wildcardSelectorId() = atSpan(in.skipToken()) { Ident(nme.WILDCARD) }
-      def givenSelectorId(start: Offset) = atSpan(start) { Ident(nme.EMPTY) }
+    /** ImportExpr       ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec
+     *                     |  SimpleRef ‘as’ id
+     *  ImportSpec       ::=  NamedSelector
+     *                     |  WildcardSelector
+     *                     | ‘{’ ImportSelectors ‘}’
+     *  ImportSelectors  ::=  NamedSelector [‘,’ ImportSelectors]
+     *                     |  WildCardSelector {‘,’ WildCardSelector}
+     *  NamedSelector    ::=  id [‘as’ (id | ‘_’)]
+     *  WildCardSelector ::=  ‘*' | ‘given’ [InfixType]
+     */
+    def importExpr(mkTree: ImportConstr): () => Tree =
+
+      /** ‘*' | ‘_' */
+      def wildcardSelector() =
+        if in.token == USCORE && sourceVersion.isAtLeast(`3.1`) then
+          report.errorOrMigrationWarning(
+            em"`_` is no longer supported for a wildcard import; use `*` instead${rewriteNotice("3.1")}",
+            in.sourcePos())
+          patch(source, Span(in.offset, in.offset + 1), "*")
+        ImportSelector(atSpan(in.skipToken()) { Ident(nme.WILDCARD) })
+
+      /** 'given [InfixType]' */
+      def givenSelector() =
+        ImportSelector(
+          atSpan(in.skipToken()) { Ident(nme.EMPTY) },
+          bound =
+            if canStartTypeTokens.contains(in.token) then rejectWildcardType(infixType())
+            else EmptyTree)
+
+      /** id [‘as’ (id | ‘_’) */
+      def namedSelector(from: Ident) =
+        if in.token == ARROW || isIdent(nme.as) then
+          if in.token == ARROW && sourceVersion.isAtLeast(`3.1`) then
+            report.errorOrMigrationWarning(
+              em"The import renaming `a => b` is no longer supported ; use `a as b` instead${rewriteNotice("3.1")}",
+              in.sourcePos())
+            patch(source, Span(in.offset, in.offset + 2),
+                if testChar(in.offset - 1, ' ') && testChar(in.offset + 2, ' ') then "as"
+                else " as ")
+          atSpan(startOffset(from), in.skipToken()) {
+            val to = if in.token == USCORE then wildcardIdent() else termIdent()
+            ImportSelector(from, if to.name == nme.ERROR then EmptyTree else to)
+          }
+        else ImportSelector(from)
 
-      /** ImportSelectors  ::=  id [‘=>’ id | ‘=>’ ‘_’] [‘,’ ImportSelectors]
-       *                     |  WildCardSelector {‘,’ WildCardSelector}
-       *  WildCardSelector ::=  ‘given’ [InfixType]
-       *                     |  ‘_'
-       */
       def importSelectors(idOK: Boolean): List[ImportSelector] =
-        val isWildcard = in.token == USCORE || in.token == GIVEN
+        val isWildcard = in.token == USCORE || in.token == GIVEN || isIdent(nme.raw.STAR)
         val selector = atSpan(in.offset) {
           in.token match
-            case USCORE =>
-              ImportSelector(wildcardSelectorId())
-            case GIVEN =>
-              val start = in.skipToken()
-              if in.token == USCORE then
-                deprecationWarning(em"`given _` is deprecated in imports; replace with just `given`", start)
-                in.nextToken()
-                ImportSelector(givenSelectorId(start)) // Let the selector span all of `given`; needed for -Ytest-pickler
-              else if canStartTypeTokens.contains(in.token) then
-                ImportSelector(givenSelectorId(start), bound = rejectWildcardType(infixType()))
-              else
-                ImportSelector(givenSelectorId(start))
+            case USCORE => wildcardSelector()
+            case GIVEN => givenSelector()
             case _ =>
-              val from = termIdent()
-              if !idOK then syntaxError(i"named imports cannot follow wildcard imports")
-              if in.token == ARROW then
-                atSpan(startOffset(from), in.skipToken()) {
-                  val to = if in.token == USCORE then wildcardIdent() else termIdent()
-                  ImportSelector(from, if to.name == nme.ERROR then EmptyTree else to)
-                }
-              else ImportSelector(from)
+              if isIdent(nme.raw.STAR) then wildcardSelector()
+              else
+                if !idOK then syntaxError(i"named imports cannot follow wildcard imports")
+                namedSelector(termIdent())
         }
         val rest =
           if in.token == COMMA then
@@ -3149,26 +3163,36 @@ object Parsers {
         selector :: rest
 
       def importSelection(qual: Tree): Tree =
-        accept(DOT)
-        in.token match
-          case USCORE =>
-            mkTree(qual, ImportSelector(wildcardSelectorId()) :: Nil)
-          case GIVEN =>
-            mkTree(qual, ImportSelector(givenSelectorId(in.skipToken())) :: Nil)
-          case LBRACE =>
-            mkTree(qual, inBraces(importSelectors(idOK = true)))
-          case _ =>
-            val start = in.offset
-            val name = ident()
-            if in.token == DOT then
-              importSelection(atSpan(startOffset(qual), start) { Select(qual, name) })
-            else
-              atSpan(startOffset(qual)) {
-                mkTree(qual, ImportSelector(atSpan(start) { Ident(name) }) :: Nil)
-              }
-
-      () => importSelection(simpleRef())
-    }
+        if in.isIdent(nme.as) && qual.isInstanceOf[RefTree] then
+          qual match
+            case Select(qual1, name) =>
+              val from = Ident(name).withSpan(Span(qual.span.point, qual.span.end, 0))
+              mkTree(qual1, namedSelector(from) :: Nil)
+            case qual: Ident =>
+              mkTree(EmptyTree, namedSelector(qual) :: Nil)
+        else
+          accept(DOT)
+          in.token match
+            case USCORE =>
+              mkTree(qual, wildcardSelector() :: Nil)
+            case GIVEN =>
+              mkTree(qual, givenSelector() :: Nil)
+            case LBRACE =>
+              mkTree(qual, inBraces(importSelectors(idOK = true)))
+            case _ =>
+              if isIdent(nme.raw.STAR) then
+                mkTree(qual, wildcardSelector() :: Nil)
+              else
+                val start = in.offset
+                val name = ident()
+                if in.token == DOT then
+                  importSelection(atSpan(startOffset(qual), start) { Select(qual, name) })
+                else
+                  mkTree(qual, namedSelector(atSpan(start) { Ident(name) }) :: Nil)
+      end importSelection
+
+      () => atSpan(in.offset) { importSelection(simpleRef()) }
+    end importExpr
 
     /** Def      ::= val PatDef
      *             | var VarDef

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -340,9 +340,13 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
       def selectorText(sel: untpd.ImportSelector): Text =
         val id: Text =
-          if sel.isGiven then keywordText("given") else toText(sel.imported)
+          if sel.isGiven then keywordText("given")
+          else sel.imported.name match
+            case nme.WILDCARD => "*"
+            case nme.raw.STAR => "`*`"
+            case name => toText(name)
         val rename: Text =
-          if sel.renamed.isEmpty then "" else Str(" => ") ~ toText(sel.renamed)
+          if sel.renamed.isEmpty then "" else Str(" as ") ~ toText(sel.renamed)
         val bound: Text =
           if sel.bound.isEmpty then ""
           else if sel.isGiven then Str(" ") ~ toText(sel.bound)

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.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/transform/FirstTransform.scala

@@ -693,7 +693,7 @@ class Namer { typer: Typer =>
     // make sure testing contexts are not captured by completers
     assert(!ictx.reporter.isInstanceOf[ExploringReporter])
 
-    protected def typeSig(sym: Symbol): Type = original match {
+    protected def typeSig(sym: Symbol): Type = original match
       case original: ValDef =>
         if (sym.is(Module)) moduleValSig(sym)
         else valOrDefDefSig(original, sym, Nil, identity)(using localContext(sym).setNewScope)
@@ -702,16 +702,12 @@ class Namer { typer: Typer =>
         nestedTyper(sym) = typer1
         typer1.defDefSig(original, sym)(using localContext(sym).setTyper(typer1))
       case imp: Import =>
-        try {
-          val expr1 = typedAheadExpr(imp.expr, AnySelectionProto)
+        try
+          val expr1 = typedImportQualifier(imp, typedAheadExpr)
           ImportType(expr1)
-        }
-        catch {
-          case ex: CyclicReference =>
-            typr.println(s"error while completing ${imp.expr}")
-            throw ex
-        }
-    }
+        catch case ex: CyclicReference =>
+          typr.println(s"error while completing ${imp.expr}")
+          throw ex
 
     final override def complete(denot: SymDenotation)(using Context): Unit = {
       if (Config.showCompletions && ctx.typerState != creationContext.typerState) {
@@ -987,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)