Also check unselected this references in enum cases.

Author: odersky

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

@@ -745,18 +745,27 @@ trait Checking {
 
   /** Check that all non-synthetic references of the form `<ident>` or
    *  `this.<ident>` in `tree` that refer to a member of `badOwner` are
-   *  `allowed`.
+   *  `allowed`. Also check that there are no other explicit `this` references
+   *  to `badOwner`.
    */
   def checkRefsLegal(tree: tpd.Tree, badOwner: Symbol, allowed: (Name, Symbol) => Boolean, where: String)(implicit ctx: Context): Unit = {
-    tree.foreachSubTree { tree =>
-      tree match {
-        case Ident(_) | Select(This(_), _) if tree.pos.isSourceDerived =>
-          val sym = tree.symbol
-          if (sym.maybeOwner == badOwner && !allowed(tree.asInstanceOf[RefTree].name, sym))
-            ctx.error(i"illegal reference to $sym from $where: $tree // ${tree.toString}", tree.pos)
-        case _ =>
+    val checker = new TreeTraverser {
+      def traverse(t: Tree)(implicit ctx: Context) = {
+        def check(owner: Symbol, checkedSym: Symbol) =
+          if (t.pos.isSourceDerived && owner == badOwner)
+            t match {
+              case t: RefTree if allowed(t.name, checkedSym) =>
+              case _ => ctx.error(i"illegal reference to $checkedSym from $where", t.pos)
+            }
+        val sym = t.symbol
+        t match {
+          case Ident(_) | Select(This(_), _) => check(sym.maybeOwner, sym)
+          case This(_) => check(sym, sym)
+          case _ => traverseChildren(t)
+        }
       }
     }
+    checker.traverse(tree)
   }
 
   /** Check that all case classes that extend `scala.Enum` are `enum` cases */

docs/docs/reference/enums/desugarEnums.md

@@ -173,14 +173,11 @@ Companion objects that contain at least one simple case define in addition:
 
 ### Scopes for Enum Cases
 
-A case in an `enum` is treated similarly to a secondary constructor. It cannot access
-with simple identifiers value parameters or instance members of the enclosing `enum`.
-
-Even though translated enum cases are located in the enum's companion object, they
-cannot access with simple identifiers any members defined locally in the enclosing
-object either. The compiler is free to typecheck enum cases in the scope of the
-enclosing companion object but it must then flag any illegal accesses to the object's
-members.
+A case in an `enum` is treated similarly to a secondary constructor. It can access neither the enclosing `enum` using `this`, nor its value parameters or instance members using simple
+identifiers.
+
+Even though translated enum cases are located in the enum's companion object, referencing
+this object or its members via `this` or a simple identifier is also illegal. The compiler typechecks enum cases in the scope of the enclosing companion object but flags any such illegal accesses as errors.
 
 ### Other Rules
 

tests/neg/enumsAccess.scala

@@ -84,3 +84,13 @@ object test6 {
     val defaultX = 2
   }
 }
+
+object test7 {
+
+  trait Arg
+
+  enum E(x: Arg) {
+    case C extends E(this) // error: illegal reference to `this`
+  }
+  object E extends Arg
+}