Make sure language imports are detectable syntactically

Make sure that something is a language import if and only if it
looks like one. i.e. is of one of the forms

    import language.xyz
    import scala.language.xyz
    import _root_.scala.language.xyz

Author: odersky

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

@@ -251,6 +251,22 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case TypeDefs(_) => true
     case _ => isUsingClause(params)
 
+  private val languageImportParts = List(nme.language, nme.scala, nme.ROOTPKG)
+  private val languageImportNested = Set[Name](nme.experimental)
+
+  /** Strip the name of any local object in `scala.language` from `path` */
+  def stripLanguageNested(path: Tree): Tree = path match
+    case Select(qual, name) if languageImportNested.contains(name) => qual
+    case _ => path
+
+  /** Does this `path` look like a language import? */
+  def isLanguageImport(path: Tree): Boolean =
+    def parts(tree: Tree): List[Name] = tree match
+      case tree: RefTree => tree.name :: parts(tree.qualifier)
+      case EmptyTree => Nil
+      case _ => EmptyTermName :: Nil
+    !path.isEmpty && languageImportParts.startsWith(parts(stripLanguageNested(path)))
+
   /** The underlying pattern ignoring any bindings */
   def unbind(x: Tree): Tree = unsplice(x) match {
     case Bind(_, y) => unbind(y)

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

@@ -474,13 +474,8 @@ object Contexts {
       else fresh.setOwner(exprOwner)
 
     /** A new context that summarizes an import statement */
-    def importContext(imp: Import[?], sym: Symbol): FreshContext = {
-      val impNameOpt = imp.expr match {
-        case ref: RefTree[?] => Some(ref.name.asTermName)
-        case _               => None
-      }
-      fresh.setImportInfo(ImportInfo(sym, imp.selectors, impNameOpt))
-    }
+    def importContext(imp: Import[?], sym: Symbol): FreshContext =
+       fresh.setImportInfo(ImportInfo(sym, imp.selectors, imp.expr))
 
     /** Is the debug option set? */
     def debug: Boolean = base.settings.Ydebug.value

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

@@ -3068,11 +3068,7 @@ object Parsers {
 
     /** Create an import node and handle source version imports */
     def mkImport(outermost: Boolean = false): ImportConstr = (tree, selectors) =>
-      val isLanguageImport = tree match
-        case Ident(nme.language) => true
-        case Select(Ident(nme.scala), nme.language) => true
-        case _ => false
-      if isLanguageImport then
+      if isLanguageImport(tree) then
         for
           case ImportSelector(id @ Ident(imported), EmptyTree, _) <- selectors
           if allSourceVersionNames.contains(imported)

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

@@ -734,9 +734,15 @@ trait Checking {
   }
 
   /** Check that `path` is a legal prefix for an import clause */
-  def checkLegalImportPath(path: Tree)(using Context): Unit = {
+  def checkLegalImportPath(path: Tree)(using Context): Unit =
     checkLegalImportOrExportPath(path, "import prefix")
-  }
+    val normPath = stripLanguageNested(path)
+    if isLanguageImport(normPath) then
+      if normPath.symbol != defn.LanguageModule then
+        report.error(em"import looks like a language import, but refers to something else: ${normPath.symbol.showLocated}", path.srcPos)
+    else
+      if normPath.tpe.classSymbols.contains(defn.LanguageModule.moduleClass) then
+        report.error(em"no aliases can be used to refer to a language import", path.srcPos)
 
   /** Check that `path` is a legal prefix for an export clause */
   def checkLegalExportPath(path: Tree, selectors: List[untpd.ImportSelector])(using Context): Unit =

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

@@ -33,7 +33,7 @@ object ImportInfo {
       val expr = tpd.Ident(ref.refFn()) // refFn must be called in the context of ImportInfo.sym
       tpd.Import(expr, selectors).symbol
 
-    ImportInfo(sym, selectors, None, isRootImport = true)
+    ImportInfo(sym, selectors, untpd.EmptyTree, isRootImport = true)
 
   extension (c: Context)
     def withRootImports(rootRefs: List[RootRef])(using Context): Context =
@@ -42,22 +42,26 @@ object ImportInfo {
     def withRootImports: Context =
       given Context = c
       c.withRootImports(defn.rootImportFns)
-
 }
 
 /** Info relating to an import clause
  *  @param   sym           The import symbol defined by the clause
  *  @param   selectors     The selector clauses
- *  @param   symNameOpt    Optionally, the name of the import symbol. None for root imports.
+ *  @param   qualifier     The import qualifier, or EmptyTree for root imports.
  *                         Defined for all explicit imports from ident or select nodes.
  *  @param   isRootImport  true if this is one of the implicit imports of scala, java.lang,
  *                         scala.Predef in the start context, false otherwise.
  */
 class ImportInfo(symf: Context ?=> Symbol,
                  val selectors: List[untpd.ImportSelector],
-                 symNameOpt: Option[TermName],
+                 val qualifier: untpd.Tree,
                  val isRootImport: Boolean = false) extends Showable {
 
+  private def symNameOpt = qualifier match {
+    case ref: untpd.RefTree => Some(ref.name.asTermName)
+    case _                  => None
+  }
+
   def sym(using Context): Symbol = {
     if (mySym == null) {
       mySym = symf
@@ -177,6 +181,8 @@ class ImportInfo(symf: Context ?=> Symbol,
       assert(myUnimported != null)
     myUnimported
 
+  private val isLanguageImport: Boolean = untpd.isLanguageImport(qualifier)
+
   private var myUnimported: Symbol = _
 
   private var myOwner: Symbol = null
@@ -185,14 +191,15 @@ class ImportInfo(symf: Context ?=> Symbol,
   /** Does this import clause or a preceding import clause import `owner.feature`? */
   def featureImported(feature: TermName, owner: Symbol)(using Context): Boolean =
 
-    def compute =
-      val isImportOwner = site.typeSymbol.eq(owner)
-      if isImportOwner && forwardMapping.contains(feature) then true
-      else if isImportOwner && excluded.contains(feature) then false
-      else
-        var c = ctx.outer
-        while c.importInfo eq ctx.importInfo do c = c.outer
-        (c.importInfo != null) && c.importInfo.featureImported(feature, owner)(using c)
+    def compute: Boolean =
+      if isLanguageImport then
+        val isImportOwner = site.typeSymbol.eq(owner)
+        if isImportOwner then
+          if forwardMapping.contains(feature) then return true
+          if excluded.contains(feature) then return false
+      var c = ctx.outer
+      while c.importInfo eq ctx.importInfo do c = c.outer
+      (c.importInfo != null) && c.importInfo.featureImported(feature, owner)(using c)
 
     if myOwner.ne(owner) || !myResults.contains(feature) then
       myOwner = owner

tests/neg/language-import.scala

@@ -0,0 +1,23 @@
+object a with
+  val l = _root_.scala.language
+  import l.noAutoTupling     // error
+  import l.experimental.genericNumberLiterals  // error
+  val scala = c
+  import scala.language.noAutoTupling  // error
+  val language = b
+  import language.experimental.genericNumberLiterals // error
+
+object b with
+  val strictEquality = 22
+  object experimental with
+    val genericNumberLiterals = 22
+
+object c with
+  val language = b
+  import b.strictEquality
+
+object d with
+  import language.experimental.genericNumberLiterals // ok
+  import scala.language.noAutoTupling  // ok
+  import _root_.scala.language.strictEquality // ok
+