Refactor imports and implement new given import syntax

The new given import syntax required a wholesale refactorings of imports.
It's shorter, clearer, and more strictly typed now.

Author: odersky

compiler/src/dotty/tools/dotc/Run.scala

@@ -54,8 +54,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       .setTyperState(new TyperState(ctx.typerState))
       .setFreshNames(new FreshNameCreator.Default)
     ctx.initialize()(start) // re-initialize the base context with start
-    def addImport(ctx: Context, refFn: () => TermRef) =
-      ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
+    def addImport(ctx: Context, rootRef: ImportInfo.RootRef) =
+      ctx.fresh.setImportInfo(ImportInfo.rootImport(rootRef)(ctx))
     defn.RootImportFns.foldLeft(start.setRun(this))(addImport)
   }
 

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

@@ -476,17 +476,18 @@ object desugar {
           stat
       }
       // The Identifiers defined by a case
-      def caseIds(tree: Tree) = tree match {
+      def caseIds(tree: Tree): List[Ident] = tree match {
         case tree: MemberDef => Ident(tree.name.toTermName) :: Nil
-        case PatDef(_, ids, _, _) => ids
+        case PatDef(_, ids: List[Ident] @ unchecked, _, _) => ids
       }
       val stats = impl.body.map(expandConstructor)
       if (isEnum) {
         val (enumCases, enumStats) = stats.partition(DesugarEnums.isEnumCase)
         if (enumCases.isEmpty)
           ctx.error("Enumerations must constain at least one case", namePos)
         val enumCompanionRef = TermRefTree()
-        val enumImport = Import(importGiven = false, enumCompanionRef, enumCases.flatMap(caseIds))
+        val enumImport =
+          Import(enumCompanionRef, enumCases.flatMap(caseIds).map(ImportSelector(_)))
         (enumImport :: enumStats, enumCases, enumCompanionRef)
       }
       else (stats, Nil, EmptyTree)

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

@@ -360,7 +360,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   def statPurity(tree: Tree)(implicit ctx: Context): PurityLevel = unsplice(tree) match {
     case EmptyTree
        | TypeDef(_, _)
-       | Import(_, _, _)
+       | Import(_, _)
        | DefDef(_, _, _, _, _) =>
       Pure
     case vdef @ ValDef(_, _, _) =>

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

@@ -803,7 +803,7 @@ object Trees {
    *  where a selector is either an untyped `Ident`, `name` or
    *  an untyped thicket consisting of `name` and `rename`.
    */
-  case class Import[-T >: Untyped] private[ast] (importGiven: Boolean, expr: Tree[T], selectors: List[Tree[Untyped]])(implicit @constructorOnly src: SourceFile)
+  case class Import[-T >: Untyped] private[ast] (expr: Tree[T], selectors: List[untpd.ImportSelector])(implicit @constructorOnly src: SourceFile)
     extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] = Import[T]
   }
@@ -1191,9 +1191,9 @@ object Trees {
         case tree: Template if (constr eq tree.constr) && (parents eq tree.parents) && (derived eq tree.derived) && (self eq tree.self) && (body eq tree.unforcedBody) => tree
         case tree => finalize(tree, untpd.Template(constr, parents, derived, self, body)(sourceFile(tree)))
       }
-      def Import(tree: Tree)(importGiven: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = tree match {
-        case tree: Import if (importGiven == tree.importGiven) && (expr eq tree.expr) && (selectors eq tree.selectors) => tree
-        case _ => finalize(tree, untpd.Import(importGiven, expr, selectors)(sourceFile(tree)))
+      def Import(tree: Tree)(expr: Tree, selectors: List[untpd.ImportSelector])(implicit ctx: Context): Import = tree match {
+        case tree: Import if (expr eq tree.expr) && (selectors eq tree.selectors) => tree
+        case _ => finalize(tree, untpd.Import(expr, selectors)(sourceFile(tree)))
       }
       def PackageDef(tree: Tree)(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef = tree match {
         case tree: PackageDef if (pid eq tree.pid) && (stats eq tree.stats) => tree
@@ -1335,8 +1335,8 @@ object Trees {
             cpy.TypeDef(tree)(name, transform(rhs))
           case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
             cpy.Template(tree)(transformSub(constr), transform(tree.parents), Nil, transformSub(self), transformStats(tree.body))
-          case Import(importGiven, expr, selectors) =>
-            cpy.Import(tree)(importGiven, transform(expr), selectors)
+          case Import(expr, selectors) =>
+            cpy.Import(tree)(transform(expr), selectors)
           case PackageDef(pid, stats) =>
             cpy.PackageDef(tree)(transformSub(pid), transformStats(stats)(localCtx))
           case Annotated(arg, annot) =>
@@ -1455,7 +1455,7 @@ object Trees {
               this(x, rhs)
             case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
               this(this(this(this(x, constr), parents), self), tree.body)
-            case Import(_, expr, _) =>
+            case Import(expr, _) =>
               this(x, expr)
             case PackageDef(pid, stats) =>
               this(this(x, pid), stats)(localCtx)

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

@@ -333,8 +333,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Block(cdef :: Nil, New(cls.typeRef, Nil))
   }
 
-  def Import(importGiven: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
-    ta.assignType(untpd.Import(importGiven, expr, selectors), ctx.newImportSymbol(ctx.owner, expr))
+  def Import(expr: Tree, selectors: List[untpd.ImportSelector])(implicit ctx: Context): Import =
+    ta.assignType(untpd.Import(expr, selectors), ctx.newImportSymbol(ctx.owner, expr))
 
   def PackageDef(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef =
     ta.assignType(untpd.PackageDef(pid, stats), pid)
@@ -1292,16 +1292,11 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    * @return The symbols imported.
    */
   def importedSymbols(imp: Import,
-                      selectorPredicate: untpd.Tree => Boolean = util.common.alwaysTrue)
+                      selectorPredicate: untpd.ImportSelector => Boolean = util.common.alwaysTrue)
                      (implicit ctx: Context): List[Symbol] =
-    imp.selectors.find(selectorPredicate) match {
-      case Some(id: untpd.Ident) =>
-        importedSymbols(imp.expr, id.name)
-      case Some(Thicket((id: untpd.Ident) :: (_: untpd.Ident) :: Nil)) =>
-        importedSymbols(imp.expr, id.name)
-      case _ =>
-        Nil
-    }
+    imp.selectors.find(selectorPredicate) match
+      case Some(sel) => importedSymbols(imp.expr, sel.name)
+      case _ => Nil
 
   /**
    * The list of select trees that resolve to the same symbols as the ones that are imported
@@ -1326,16 +1321,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-    imp.selectors.flatMap {
-      case Ident(nme.WILDCARD) =>
-        Nil
-      case id: untpd.Ident =>
-        importedSymbols(imp.expr, id.name).flatMap { sym =>
-          imported(sym, id, None)
-        }
-      case Thicket((id: untpd.Ident) :: (newName: untpd.Ident) :: Nil) =>
-        importedSymbols(imp.expr, id.name).flatMap { sym =>
-          imported(sym, id, Some(newName))
+    imp.selectors.flatMap { sel =>
+      if sel.isWildcard then Nil
+      else
+        val renamedOpt = sel.renamed match
+          case renamed: untpd.Ident => Some(renamed)
+          case untpd.EmptyTree => None
+        importedSymbols(imp.expr, sel.name).flatMap { sym =>
+          imported(sym, sel.imported, renamedOpt)
         }
     }
   }

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

@@ -108,7 +108,25 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class GenAlias(pat: Tree, expr: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
   case class ContextBounds(bounds: TypeBoundsTree, cxBounds: List[Tree])(implicit @constructorOnly src: SourceFile) extends TypTree
   case class PatDef(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree)(implicit @constructorOnly src: SourceFile) extends DefTree
-  case class Export(impliedOnly: Boolean, expr: Tree, selectors: List[Tree])(implicit @constructorOnly src: SourceFile) extends Tree
+  case class Export(expr: Tree, selectors: List[ImportSelector])(implicit @constructorOnly src: SourceFile) extends Tree
+
+  case class ImportSelector(imported: Ident, renamed: Tree = EmptyTree, bound: Tree = EmptyTree)(implicit @constructorOnly src: SourceFile) extends Tree {
+
+    /** It's a `given` selector */
+    val isGiven: Boolean = imported.name.isEmpty
+
+    /** It's a `given` or `_` selector */
+    val isWildcard: Boolean = isGiven || imported.name == nme.WILDCARD
+
+    /** The imported name, EmptyTermName if it's a given selector */
+    val name: TermName = imported.name.asInstanceOf[TermName]
+
+    /** The renamed part (which might be `_`), if present, or `name`, if missing */
+    val rename: TermName = renamed match
+      case Ident(rename: TermName) => rename
+      case _ => name
+  }
+
   case class Number(digits: String, kind: NumberKind)(implicit @constructorOnly src: SourceFile) extends TermTree
 
   enum NumberKind {
@@ -344,7 +362,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Template(constr: DefDef, parents: List[Tree], derived: List[Tree], self: ValDef, body: LazyTreeList)(implicit src: SourceFile): Template =
     if (derived.isEmpty) new Template(constr, parents, self, body)
     else new DerivingTemplate(constr, parents ++ derived, self, body, derived.length)
-  def Import(importGiven: Boolean, expr: Tree, selectors: List[Tree])(implicit src: SourceFile): Import = new Import(importGiven, expr, selectors)
+  def Import(expr: Tree, selectors: List[ImportSelector])(implicit src: SourceFile): Import = new Import(expr, selectors)
   def PackageDef(pid: RefTree, stats: List[Tree])(implicit src: SourceFile): PackageDef = new PackageDef(pid, stats)
   def Annotated(arg: Tree, annot: Tree)(implicit src: SourceFile): Annotated = new Annotated(arg, annot)
 
@@ -561,9 +579,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: PatDef if (mods eq tree.mods) && (pats eq tree.pats) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
       case _ => finalize(tree, untpd.PatDef(mods, pats, tpt, rhs)(tree.source))
     }
-    def Export(tree: Tree)(impliedOnly: Boolean, expr: Tree, selectors: List[Tree])(implicit ctx: Context): Tree = tree match {
-      case tree: Export if (impliedOnly == tree.impliedOnly) && (expr eq tree.expr) && (selectors eq tree.selectors) => tree
-      case _ => finalize(tree, untpd.Export(impliedOnly, expr, selectors)(tree.source))
+    def Export(tree: Tree)(expr: Tree, selectors: List[ImportSelector])(implicit ctx: Context): Tree = tree match {
+      case tree: Export if (expr eq tree.expr) && (selectors eq tree.selectors) => tree
+      case _ => finalize(tree, untpd.Export(expr, selectors)(tree.source))
+    }
+    def ImportSelector(tree: Tree)(imported: Ident, renamed: Tree, bound: Tree)(implicit ctx: Context): Tree = tree match {
+      case tree: ImportSelector if (imported eq tree.imported) && (renamed eq tree.renamed) && (bound eq tree.bound) => tree
+      case _ => finalize(tree, untpd.ImportSelector(imported, renamed, bound)(tree.source))
     }
     def Number(tree: Tree)(digits: String, kind: NumberKind)(implicit ctx: Context): Tree = tree match {
       case tree: Number if (digits == tree.digits) && (kind == tree.kind) => tree
@@ -621,8 +643,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.ContextBounds(tree)(transformSub(bounds), transform(cxBounds))
       case PatDef(mods, pats, tpt, rhs) =>
         cpy.PatDef(tree)(mods, transform(pats), transform(tpt), transform(rhs))
-      case Export(impliedOnly, expr, selectors) =>
-        cpy.Export(tree)(impliedOnly, transform(expr), selectors)
+      case Export(expr, selectors) =>
+        cpy.Export(tree)(transform(expr), selectors)
+      case ImportSelector(imported, renamed, bound) =>
+        cpy.ImportSelector(tree)(transformSub(imported), transform(renamed), transform(bound))
       case Number(_, _) | TypedSplice(_) =>
         tree
       case _ =>
@@ -676,8 +700,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(this(x, bounds), cxBounds)
       case PatDef(mods, pats, tpt, rhs) =>
         this(this(this(x, pats), tpt), rhs)
-      case Export(_, expr, _) =>
+      case Export(expr, _) =>
         this(x, expr)
+      case ImportSelector(imported, renamed, bound) =>
+        this(this(this(x, imported), renamed), bound)
       case Number(_, _) =>
         x
       case TypedSplice(splice) =>

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

@@ -214,7 +214,7 @@ object Contexts {
         implicitsCache = {
           val implicitRefs: List[ImplicitRef] =
             if (isClassDefContext)
-              try owner.thisType.implicitMembers(GivenOrImplicit)
+              try owner.thisType.implicitMembers
               catch {
                 case ex: CyclicReference => Nil
               }
@@ -405,8 +405,7 @@ object Contexts {
         case ref: RefTree[?] => Some(ref.name.asTermName)
         case _               => None
       }
-      ctx.fresh.setImportInfo(
-        ImportInfo(sym, imp.selectors, impNameOpt, imp.importGiven))
+      ctx.fresh.setImportInfo(ImportInfo(sym, imp.selectors, impNameOpt))
     }
 
     /** Does current phase use an erased types interpretation? */

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

@@ -10,6 +10,7 @@ import scala.collection.mutable
 import collection.mutable
 import Denotations.SingleDenotation
 import util.SimpleIdentityMap
+import typer.ImportInfo.RootRef
 
 import scala.annotation.tailrec
 
@@ -1028,23 +1029,23 @@ class Definitions {
   def isPredefClass(cls: Symbol): Boolean =
     (cls.owner eq ScalaPackageClass) && predefClassNames.contains(cls.name)
 
-  val StaticRootImportFns: List[() => TermRef] = List[() => TermRef](
-    () => JavaLangPackageVal.termRef,
-    () => ScalaPackageVal.termRef
+  val StaticRootImportFns: List[RootRef] = List[RootRef](
+    (() => JavaLangPackageVal.termRef, false),
+    (() => ScalaPackageVal.termRef, false)
   )
 
-  val PredefImportFns: List[() => TermRef] = List[() => TermRef](
-    () => ScalaPredefModule.termRef,
-    () => DottyPredefModule.termRef
+  val PredefImportFns: List[RootRef] = List[RootRef](
+    (() => ScalaPredefModule.termRef, true),
+    (() => DottyPredefModule.termRef, false)
   )
 
-  @tu lazy val RootImportFns: List[() => TermRef] =
-    if (ctx.settings.YnoImports.value) List.empty[() => TermRef]
+  @tu lazy val RootImportFns: List[RootRef] =
+    if (ctx.settings.YnoImports.value) Nil
     else if (ctx.settings.YnoPredef.value) StaticRootImportFns
     else StaticRootImportFns ++ PredefImportFns
 
   @tu lazy val ShadowableImportNames: Set[TermName] = Set("Predef", "DottyPredef").map(_.toTermName)
-  @tu lazy val RootImportTypes: List[TermRef] = RootImportFns.map(_())
+  @tu lazy val RootImportTypes: List[TermRef] = RootImportFns.map(_._1())
 
   /** Modules whose members are in the default namespace and their module classes */
   @tu lazy val UnqualifiedOwnerTypes: Set[NamedType] =

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

@@ -19,6 +19,7 @@ import printing.Printer
 import io.AbstractFile
 import config.Config
 import util.common._
+import typer.ProtoTypes.NoViewsAllowed
 import collection.mutable.ListBuffer
 
 /** Denotations represent the meaning of symbols and named types.
@@ -766,6 +767,11 @@ object Denotations {
       if (matches) this else NoDenotation
     }
 
+    def matchesImportBound(bound: Type)(implicit ctx: Context): Boolean =
+      if bound.isRef(defn.NothingClass) then false
+      else if bound.isRef(defn.AnyClass) then true
+      else NoViewsAllowed.normalizedCompatible(info, bound, keepConstraint = false)
+
     // ------ Transformations -----------------------------------------
 
     private[this] var myValidFor: Period = Nowhere

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

@@ -799,10 +799,10 @@ object Types {
      *  @param kind   A subset of {Implicit, Given} that specifies what kind of implicit should
      *                be returned
      */
-    final def implicitMembers(kind: FlagSet)(implicit ctx: Context): List[TermRef] = {
+    final def implicitMembers(implicit ctx: Context): List[TermRef] = {
       record("implicitMembers")
       memberDenots(implicitFilter,
-          (name, buf) => buf ++= member(name).altsWith(_.isOneOf(GivenOrImplicitVal & kind)))
+          (name, buf) => buf ++= member(name).altsWith(_.isOneOf(GivenOrImplicitVal)))
         .toList.map(d => TermRef(this, d.symbol.asTerm))
     }