Merge pull request scala#6764 from som-snytt/issue/yimports-2.13

Support -Yimports for implicit preamble imports

Author: adriaanm

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -15,6 +15,7 @@ import scala.language.existentials
 import scala.annotation.elidable
 import scala.tools.util.PathResolver.Defaults
 import scala.collection.mutable
+import scala.reflect.internal.util.StringContextStripMarginOps
 
 trait ScalaSettings extends AbsScalaSettings
                        with StandardScalaSettings
@@ -201,7 +202,30 @@ trait ScalaSettings extends AbsScalaSettings
   val Ylogcp          = BooleanSetting    ("-Ylog-classpath", "Output information about what classpath is being applied.")
   val Ynogenericsig   = BooleanSetting    ("-Yno-generic-signatures", "Suppress generation of generic signatures for Java.")
   val noimports       = BooleanSetting    ("-Yno-imports", "Compile without importing scala.*, java.lang.*, or Predef.")
+                       .withPostSetHook(bs => if (bs) imports.value = Nil)
   val nopredef        = BooleanSetting    ("-Yno-predef", "Compile without importing Predef.")
+                       .withPostSetHook(bs => if (bs && !noimports) imports.value = "java.lang" :: "scala" :: Nil)
+  val imports         = MultiStringSetting(name="-Yimports", arg="import", descr="Custom root imports, default is `java.lang,scala,scala.Predef`.", helpText=Some(
+  sm"""|Specify a list of packages and objects to import from as "root" imports.
+       |Root imports form the root context in which all Scala source is evaluated.
+       |The names supplied to `-Yimports` must be fully-qualified.
+       |
+       |For example, the default scala.Predef results in an `import scala.Predef._`.
+       |Ordinary access and scoping rules apply. Root imports increase the scoping
+       |depth, so that later root imports shadow earlier ones. In addition,
+       |names bound by root imports have lowest binding precedence, so that they
+       |cannot induce ambiguities in user code, where definitions and imports
+       |always have a higher precedence. Root imports are imports of last resort.
+       |
+       |By convention, an explicit import from a root import object such as
+       |Predef disables that root import for the current source file. The import
+       |is disabled when the import expression is compiled, so, also by convention,
+       |the import should be placed early in source code order. The textual name
+       |in the import does not need to match the value of `-Yimports`; the import
+       |works in the usual way, subject to renames and name binding precedence.
+       |
+    """
+  ))
   val Yrecursion      = IntSetting        ("-Yrecursion", "Set recursion depth used when locking symbols.", 0, Some((0, Int.MaxValue)), (_: String) => None)
   val Xshowtrees      = BooleanSetting    ("-Yshow-trees", "(Requires -Xprint:) Print detailed ASTs in formatted form.")
   val XshowtreesCompact

src/compiler/scala/tools/nsc/typechecker/Contexts.scala

@@ -79,31 +79,63 @@ trait Contexts { self: Analyzer =>
 
   var lastAccessCheckDetails: String = ""
 
-  /** List of symbols to import from in a root context.  Typically that
-   *  is `java.lang`, `scala`, and [[scala.Predef]], in that order.  Exceptions:
+  val rootImportsCached = perRunCaches.newMap[CompilationUnit, List[Symbol]]
+
+  val excludedRootImportsCached = perRunCaches.newMap[CompilationUnit, List[Symbol]]
+
+  // register an import for the narrow purpose of excluding root imports of predef modules
+  def registerImport(ctx: Context, imp: Import): Unit = {
+    val sym = imp.expr.symbol
+    if (!sym.isPackage && ctx.enclosingNonImportContext.owner.isPackage && rootImports(ctx.unit).contains(sym)) {
+      var current = excludedRootImportsCached.get(ctx.unit).getOrElse(Nil)
+      current = sym :: current
+      excludedRootImportsCached += ctx.unit -> current
+    }
+  }
+
+  /** List of symbols to import from in a root context.  By default, that
+   *  is `java.lang`, `scala`, and [[scala.Predef]], in that order.
    *
-   *  - if option `-Yno-imports` is given, nothing is imported
-   *  - if the unit is java defined, only `java.lang` is imported
-   *  - if option `-Yno-predef` is given, if the unit body has an import of Predef
+   *  - if option `-Yimports` is supplied, then that specifies the preamble imports
+   *  - if the unit body has an import of Predef
    *    among its leading imports, or if the tree is [[scala.Predef]], `Predef` is not imported.
+   *    Similarly for any module among the preamble imports.
+   *  - if the unit is java defined, only `java.lang` is imported
+   *
+   *  The root imports for a unit are cached.
    */
   protected def rootImports(unit: CompilationUnit): List[Symbol] = {
     assert(definitions.isDefinitionsInitialized, "definitions uninitialized")
 
-    if (settings.noimports) Nil
-    else if (unit.isJava) RootImports.javaList
-    else if (settings.nopredef || treeInfo.noPredefImportForUnit(unit.body)) {
-      // scala/bug#8258 Needed for the presentation compiler using -sourcepath, otherwise cycles can occur. See the commit
-      //         message for this ticket for an example.
-      debuglog("Omitted import of Predef._ for " + unit)
-      RootImports.javaAndScalaList
+    if (unit.isJava) RootImports.javaList
+    else rootImportsCached.get(unit).getOrElse {
+      val calculated = defaultRootImports
+      rootImportsCached += unit -> calculated
+      calculated
     }
-    else RootImports.completeList
   }
 
+  private def defaultRootImports: List[Symbol] = {
+    import rootMirror.{getModuleIfDefined, getPackageObjectIfDefined, getPackageIfDefined}
+
+    if (settings.imports.isSetByUser)
+      settings.imports.value.map {
+        case "java.lang"    => JavaLangPackage
+        case "scala"        => ScalaPackage
+        case "scala.Predef" => PredefModule
+        case s              =>
+          getModuleIfDefined(s) orElse
+          getPackageObjectIfDefined(s) orElse
+          getPackageIfDefined(s) orElse {
+            error(s"bad preamble import $s")
+            NoSymbol
+          }
+      }
+    else RootImports.completeList
+  }
 
   def rootContext(unit: CompilationUnit, tree: Tree = EmptyTree, throwing: Boolean = false, checking: Boolean = false): Context = {
-    val rootImportsContext = rootImports(unit).foldLeft(startContext)((c, sym) => c.make(gen.mkWildcardImport(sym)))
+    val rootImportsContext = rootImports(unit).foldLeft(startContext)((c, sym) => c.make(gen.mkWildcardImport(sym), unit = unit))
 
     // there must be a scala.xml package when xml literals were parsed in this unit
     if (unit.hasXml && ScalaXmlPackage == NoSymbol)
@@ -975,7 +1007,7 @@ trait Contexts { self: Analyzer =>
       for (sym <- syms.toList if isQualifyingImplicit(sym.name, sym, pre, imported)) yield
         new ImplicitInfo(sym.name, pre, sym)
 
-    private def collectImplicitImports(imp: ImportInfo): List[ImplicitInfo] = {
+    private def collectImplicitImports(imp: ImportInfo): List[ImplicitInfo] = if (isExcludedRootImport(imp)) List() else {
       val qual = imp.qual
 
       val pre = qual.tpe
@@ -1085,12 +1117,6 @@ trait Contexts { self: Analyzer =>
       def mt1 = t1 memberType imp1Symbol
       def mt2 = t2 memberType imp2Symbol
 
-      def characterize = List(
-        s"types:  $t1 =:= $t2  ${t1 =:= t2}  members: ${mt1 =:= mt2}",
-        s"member type 1: $mt1",
-        s"member type 2: $mt2"
-      ).mkString("\n  ")
-
       if (!ambiguous || !imp2Symbol.exists) Some(imp1)
       else if (!imp1Symbol.exists) Some(imp2)
       else (
@@ -1110,7 +1136,10 @@ trait Contexts { self: Analyzer =>
           Some(imp1)
         }
         else {
-          log(s"Import is genuinely ambiguous:\n  " + characterize)
+          log(s"""Import is genuinely ambiguous:
+                 |  types:  $t1 =:= $t2  ${t1 =:= t2}  members: ${mt1 =:= mt2}
+                 |  member type 1: $mt1
+                 |  member type 2: $mt2""".stripMargin)
           None
         }
       )
@@ -1138,7 +1167,11 @@ trait Contexts { self: Analyzer =>
      *  if any such symbol is accessible from this context.
      */
     private def importedAccessibleSymbol(imp: ImportInfo, name: Name, requireExplicit: Boolean, record: Boolean): Symbol =
-      imp.importedSymbol(name, requireExplicit, record) filter (s => isAccessible(s, imp.qual.tpe, superAccess = false))
+      if (isExcludedRootImport(imp)) NoSymbol
+      else imp.importedSymbol(name, requireExplicit, record) filter (s => isAccessible(s, imp.qual.tpe, superAccess = false))
+
+    private def isExcludedRootImport(imp: ImportInfo): Boolean =
+      imp.isRootImport && excludedRootImportsCached.get(unit).exists(_.contains(imp.qual.symbol))
 
     private def requiresQualifier(s: Symbol): Boolean = (
          s.owner.isClass
@@ -1177,11 +1210,10 @@ trait Contexts { self: Analyzer =>
           case _                                => LookupSucceeded(qual, sym)
         }
       )
-      def finishDefSym(sym: Symbol, pre0: Type): NameLookup =
-        if (requiresQualifier(sym))
-          finish(gen.mkAttributedQualifier(pre0), sym)
-        else
-          finish(EmptyTree, sym)
+      def finishDefSym(sym: Symbol, pre0: Type): NameLookup = {
+        val qual = if (requiresQualifier(sym)) gen.mkAttributedQualifier(pre0) else EmptyTree
+        finish(qual, sym)
+      }
 
       def lookupInPrefix(name: Name)    = {
         val sym = pre.member(name).filter(qualifies)

src/compiler/scala/tools/nsc/typechecker/Namers.scala

@@ -1781,6 +1781,7 @@ trait Namers extends MethodSynthesis {
         val newImport = treeCopy.Import(imp, expr1, selectors).asInstanceOf[Import]
         checkSelectors(newImport)
         context.unit.transformed(imp) = newImport
+        registerImport(context, newImport)
         // copy symbol and type attributes back into old expression
         // so that the structure builder will find it.
         expr setSymbol expr1.symbol setType expr1.tpe

src/reflect/scala/reflect/internal/TreeInfo.scala

@@ -835,7 +835,7 @@ abstract class TreeInfo {
   }
 
   /** Does list of trees start with a definition of
-   *  a class of module with given name (ignoring imports)
+   *  a class or module with given name (ignoring imports)
    */
   def firstDefinesClassOrObject(trees: List[Tree], name: Name): Boolean = trees match {
     case Import(_, _) :: xs             => firstDefinesClassOrObject(xs, name)
@@ -859,25 +859,6 @@ abstract class TreeInfo {
     }
   }
 
-  /** Is this file the body of a compilation unit which should not
-   *  have Predef imported?
-   */
-  def noPredefImportForUnit(body: Tree) = {
-    // Top-level definition whose leading imports include Predef.
-    def isLeadingPredefImport(defn: Tree): Boolean = defn match {
-      case PackageDef(_, defs1) => defs1 exists isLeadingPredefImport
-      case Import(expr, _)      => isReferenceToPredef(expr)
-      case _                    => false
-    }
-    // Compilation unit is class or object 'name' in package 'scala'
-    def isUnitInScala(tree: Tree, name: Name) = tree match {
-      case PackageDef(Ident(nme.scala_), defs) => firstDefinesClassOrObject(defs, name)
-      case _                                   => false
-    }
-
-    isUnitInScala(body, nme.Predef) || isLeadingPredefImport(body)
-  }
-
   def isAbsTypeDef(tree: Tree) = tree match {
     case TypeDef(_, _, _, TypeBoundsTree(_, _)) => true
     case TypeDef(_, _, _, rhs) => rhs.tpe.isInstanceOf[TypeBounds]

src/reflect/scala/reflect/internal/Trees.scala

@@ -1307,17 +1307,6 @@ trait Trees extends api.Trees {
     }
   }
 
-  // Belongs in TreeInfo but then I can't reach it from Printers.
-  def isReferenceToScalaMember(t: Tree, Id: Name) = t match {
-    case Ident(Id)                                          => true
-    case Select(Ident(nme.scala_), Id)                      => true
-    case Select(Select(Ident(nme.ROOTPKG), nme.scala_), Id) => true
-    case _                                                  => false
-  }
-  /** Is the tree Predef, scala.Predef, or _root_.scala.Predef?
-   */
-  def isReferenceToPredef(t: Tree) = isReferenceToScalaMember(t, nme.Predef)
-
   // --- modifiers implementation ---------------------------------------
 
   /** @param privateWithin the qualifier for a private (a type name)

test/files/neg/yimports-custom-b.check

@@ -0,0 +1,7 @@
+C_2.scala:8: error: not found: type Numb
+  val v: Numb = Answer
+         ^
+C_2.scala:9: error: not found: value println
+  def greet() = println("hello, world!")
+                ^
+two errors found

test/files/neg/yimports-custom-b/C_2.scala

@@ -0,0 +1,10 @@
+// scalac: -Yimports:hello.world.minidef
+
+import hello.{world => hw}
+import hw.minidef.{Magic => Answer}
+
+// Finds the answer, but dumb to forget Numb
+class C {
+  val v: Numb = Answer
+  def greet() = println("hello, world!")
+}

test/files/neg/yimports-custom-b/minidef_1.scala

@@ -0,0 +1,8 @@
+// scalac: -Yimports:scala
+
+package hello.world
+
+object minidef {
+  type Numb = Int
+  final val Magic = 42
+}

test/files/neg/yimports-custom.check

@@ -0,0 +1,4 @@
+C_2.scala:5: error: not found: value println
+  def greet() = println("hello, world!")
+                ^
+one error found

test/files/neg/yimports-custom/C_2.scala

@@ -0,0 +1,6 @@
+// scalac: -Yimports:hello.world.minidef
+
+class C {
+  val v: Numb = Magic
+  def greet() = println("hello, world!")
+}

test/files/neg/yimports-custom/minidef_1.scala

@@ -0,0 +1,7 @@
+
+package hello.world
+
+object minidef {
+  type Numb = Int
+  final val Magic = 42
+}

test/files/neg/yimports-masked.check

@@ -0,0 +1,7 @@
+C_2.scala:11: error: not found: type Numb
+    val v: Numb = Answer
+           ^
+C_2.scala:12: error: not found: value println
+    def greet() = println("hello, world!")
+                  ^
+two errors found

test/files/neg/yimports-masked/C_2.scala

@@ -0,0 +1,14 @@
+// scalac: -Yimports:scala,hello.world.minidef
+
+// import at top level or top of package disables implicit import.
+// the import can appear at any statement position, here, end of package.
+// Update: with new trick, the import has to be completed before usages.
+
+import hello.world.minidef.{Magic => Answer}
+
+package p {
+  class C {
+    val v: Numb = Answer
+    def greet() = println("hello, world!")
+  }
+}

test/files/neg/yimports-masked/minidef_1.scala

@@ -0,0 +1,7 @@
+
+package hello.world
+
+object minidef {
+  type Numb = Int
+  final val Magic = 42
+}

test/files/neg/yimports-nojava.check

@@ -0,0 +1,7 @@
+yimports-nojava.scala:5: error: not found: type Integer
+  def g() = new Integer(42)
+                ^
+yimports-nojava.scala:6: error: not found: value Thread
+  def sleep() = Thread.sleep(42000L)
+                ^
+two errors found

test/files/neg/yimports-nojava.scala

@@ -0,0 +1,7 @@
+// scalac: -Yimports:scala,scala.Predef
+
+trait T {
+  def f() = println("hello, world!")
+  def g() = new Integer(42)
+  def sleep() = Thread.sleep(42000L)
+}

test/files/neg/yimports-nosuch.check

@@ -0,0 +1,3 @@
+error: bad preamble import skala
+error: bad preamble import scala.Predeff
+two errors found

test/files/neg/yimports-nosuch.scala

@@ -0,0 +1,3 @@
+// scalac: -Yimports:skala,scala.Predeff
+//
+class C

test/files/neg/yimports-order.check

@@ -0,0 +1,10 @@
+yimports-order.scala:9: error: not found: value Map
+      def f() = Map("hello" -> "world")
+                ^
+yimports-order.scala:9: error: value -> is not a member of String
+      def f() = Map("hello" -> "world")
+                            ^
+yimports-order.scala:10: error: not found: value println
+      def g() = println(f())
+                ^
+three errors found

test/files/neg/yimports-order.scala

@@ -0,0 +1,13 @@
+
+package top {
+  package middle {
+    class C {
+      def c() = println("hello, world")
+    }
+    import Predef.{Map => _}
+    object Test {
+      def f() = Map("hello" -> "world")
+      def g() = println(f())
+    }
+  }
+}

test/files/neg/yimports-predef.check

@@ -0,0 +1,4 @@
+yimports-predef.scala:6: error: value + is not a member of type parameter A
+  def f[A](x: A) = x + 42
+                     ^
+one error found

test/files/neg/yimports-predef.scala

@@ -0,0 +1,7 @@
+// scalac: -Yimports:scala,scala.Predef
+//
+import Predef.{any2stringadd => _, _}
+
+class classic {
+  def f[A](x: A) = x + 42
+}

test/files/neg/yimports-stable.check

@@ -0,0 +1,2 @@
+error: bad preamble import hello.world.potions
+one error found

test/files/neg/yimports-stable/C_2.scala

@@ -0,0 +1,6 @@
+// scalac: -Yimports:scala,scala.Predef,hello.world.potions
+//
+class C {
+  val v: Numb = magic
+  def greet() = println("hello, world!")
+}