Disallow naming the root package, except for selections

Author: dwijnand

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

@@ -1072,9 +1072,16 @@ object Parsers {
       }
 
     /** Accept identifier and return Ident with its name as a term name. */
-    def termIdent(): Ident =
+    def rawTermIdent(): Ident =
       makeIdent(in.token, in.offset, ident())
 
+    /** Call `rawTermIdent`, and check it isn't a root package name. */
+    def termIdent(): Ident =
+      val ident = rawTermIdent()
+      if ident.name == nme.ROOTPKG then
+        syntaxError(em"Illegal use of root package name.")
+      ident
+
     /** Accept identifier and return Ident with its name as a type name. */
     def typeIdent(): Ident =
       makeIdent(in.token, in.offset, ident().toTypeName)
@@ -1112,7 +1119,7 @@ object Parsers {
      *              |  [id ‘.’] ‘this’
      *              |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
      */
-    def simpleRef(): Tree =
+    def simpleRef(allowRoot: Boolean = true): Tree =
       val start = in.offset
 
       def handleThis(qual: Ident) =
@@ -1129,7 +1136,7 @@ object Parsers {
       if in.token == THIS then handleThis(EmptyTypeIdent)
       else if in.token == SUPER then handleSuper(EmptyTypeIdent)
       else
-        val t = termIdent()
+        val t = if allowRoot then rawTermIdent() else termIdent()
         if in.token == DOT then
           def qual = cpy.Ident(t)(t.name.toTypeName)
           in.lookahead.token match
@@ -2965,7 +2972,7 @@ object Parsers {
      */
     def simplePattern(): Tree = in.token match {
       case IDENTIFIER | BACKQUOTED_IDENT | THIS | SUPER =>
-        simpleRef() match
+        simpleRef(allowRoot = false) match
           case id @ Ident(nme.raw.MINUS) if isNumericLit => literal(startOffset(id))
           case t => simplePatternRest(t)
       case USCORE =>

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

@@ -569,7 +569,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     // optimization, it also avoids forcing imports thus potentially avoiding
     // cyclic references.
     if (name == nme.ROOTPKG)
-      return tree.withType(defn.RootPackage.termRef)
+      val tree2 = tree.withType(defn.RootPackage.termRef)
+      checkLegalValue(tree2, pt)
+      return tree2
 
     val rawType =
       val saved1 = unimported
@@ -581,13 +583,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         if foundUnderScala2.exists && !(foundUnderScala2 =:= found) then
           report.migrationWarning(
             em"""Name resolution will change.
-              | currently selected                          : $foundUnderScala2
-              | in the future, without -source 3.0-migration: $found""", tree.srcPos)
+                | currently selected                          : $foundUnderScala2
+                | in the future, without -source 3.0-migration: $found""", tree.srcPos)
           foundUnderScala2
         else found
       finally
-      	unimported = saved1
-      	foundUnderScala2 = saved2
+        unimported = saved1
+        foundUnderScala2 = saved2
 
     /** Normally, returns `ownType` except if `ownType` is a constructor proxy,
      *  and there is another shadowed type accessible with the same name that is not:

tests/neg/i18020.scala

@@ -0,0 +1,57 @@
+import _root_.scala.StringContext // ok
+
+class Test :
+  val Foo = 1
+  def foo0: Unit =
+    val x = new _root_.scala.StringContext() // ok
+    val y: Option[_root_.scala.Serializable] = None // ok
+    val z: _root_.scala.None.type = None
+    val w = _root_.scala.None
+    val (_root_, other) = (1, 2) // error
+    val (Test.this.Foo, 1) = ???
+    ??? match
+      case (Test.this.Foo, 1) => ()
+
+def foo3 =
+  val _root_ = "abc" // error
+
+def foo1: Unit =
+  val _root_: String = "abc" // error // error
+  // _root_: is, technically, a legal name
+  // so then it tries to construct the infix op pattern
+  // "_root_ String .." and then throws in a null when it fails
+  // to find an argument
+  // then Typer rejects "String" as an infix extractor (like ::)
+  // which is the second error
+
+def foo2: Unit = // error
+  val _root_ : String = "abc" // error
+
+// i17757
+def fooVal: Unit =
+  val _root_  = "abc" // error
+  println(_root_.length)  // error
+  println(_root_)  // error
+
+def barVal: Unit =
+  _root_  // error
+  _root_.scala  // error
+  println(_root_)  // error
+  println(_root_.scala)  // error
+
+// i18050
+package p {
+  package _root_ { // error
+    object X // error
+  }
+}
+
+// i12508
+package _root_ { // error
+  class C {
+    val _root_ = 42 // error
+  }
+}
+package _root_.p { // error
+  class C
+}