Move "is this a value?" check from Typer to Erasure

Doing the check in Typer leads to cyclic errors, and I can't figure out
a nice way to do this in any other phase since it requires knowledge
about the expected type.

Author: smarter

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -328,6 +328,18 @@ object Erasure {
       case _ => tree.symbol.isEffectivelyErased
     }
 
+    /** Check that Java statics and packages can only be used in selections.
+      */
+    private def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = {
+      if (!proto.isInstanceOf[SelectionProto] && !proto.isInstanceOf[ApplyingProto]) {
+        val sym = tree.tpe.termSymbol
+        // The check is avoided inside Java compilation units because it always fails
+        // on the singleton type Module.type.
+        if ((sym is Flags.Package) || (sym.isAllOf(Flags.JavaModule) && !ctx.compilationUnit.isJava)) ctx.error(reporting.diagnostic.messages.JavaSymbolIsNotAValue(sym), tree.sourcePos)
+      }
+      tree
+    }
+
     private def checkNotErased(tree: Tree)(implicit ctx: Context): tree.type = {
       if (!ctx.mode.is(Mode.Type)) {
         if (isErased(tree))
@@ -390,7 +402,7 @@ object Erasure {
         super.typedLiteral(tree)
 
     override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context): Tree = {
-      checkNotErased(super.typedIdent(tree, pt))
+      checkValue(checkNotErased(super.typedIdent(tree, pt)), pt)
     }
 
     /** Type check select nodes, applying the following rewritings exhaustively
@@ -484,7 +496,7 @@ object Erasure {
         }
       }
 
-      checkNotErased(recur(qual1))
+      checkValue(checkNotErased(recur(qual1)), pt)
     }
 
     override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree =

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -263,7 +263,10 @@ class TreeChecker extends Phase with SymTransformer {
 
     override def typed(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = {
       val tpdTree = super.typed(tree, pt)
-      checkIdentNotJavaClass(tpdTree)
+      if (ctx.erasedTypes)
+        // Can't be checked in earlier phases since `checkValue` is only run in
+        // Erasure (because running it in Typer would force too much)
+        checkIdentNotJavaClass(tpdTree)
       tpdTree
     }
 

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

@@ -594,18 +594,6 @@ trait Checking {
   def checkNonCyclicInherited(joint: Type, parents: List[Type], decls: Scope, posd: Positioned)(implicit ctx: Context): Unit =
     Checking.checkNonCyclicInherited(joint, parents, decls, posd)
 
-  /** Check that Java statics and packages can only be used in selections.
-   */
-  def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = {
-    if (!proto.isInstanceOf[SelectionProto] && !proto.isInstanceOf[ApplyingProto]) {
-      val sym = tree.tpe.termSymbol
-      // The check is avoided inside Java compilation units because it always fails
-      // on the singleton type Module.type.
-      if ((sym is Package) || (sym.isAllOf(JavaModule) && !ctx.compilationUnit.isJava)) ctx.error(JavaSymbolIsNotAValue(sym), tree.sourcePos)
-    }
-    tree
-  }
-
   /** Check that type `tp` is stable. */
   def checkStable(tp: Type, pos: SourcePosition)(implicit ctx: Context): Unit =
     if (!tp.isStable) ctx.error(ex"$tp is not stable", pos)
@@ -1171,7 +1159,6 @@ trait NoChecking extends ReChecking {
   import tpd._
   override def checkNonCyclic(sym: Symbol, info: TypeBounds, reportErrors: Boolean)(implicit ctx: Context): Type = info
   override def checkNonCyclicInherited(joint: Type, parents: List[Type], decls: Scope, posd: Positioned)(implicit ctx: Context): Unit = ()
-  override def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = tree
   override def checkStable(tp: Type, pos: SourcePosition)(implicit ctx: Context): Unit = ()
   override def checkClassType(tp: Type, pos: SourcePosition, traitReq: Boolean, stablePrefixReq: Boolean)(implicit ctx: Context): Type = tp
   override def checkImplicitConversionDefOK(sym: Symbol)(implicit ctx: Context): Unit = ()

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

@@ -429,7 +429,6 @@ class Typer extends Namer
     }
 
     checkStableIdentPattern(tree1, pt)
-    checkValue(tree1, pt)
   }
 
   /** Check that a stable identifier pattern is indeed stable (SLS 8.1.5)
@@ -453,7 +452,7 @@ class Typer extends Namer
       }
     case qual =>
       if (tree.name.isTypeName) checkStable(qual.tpe, qual.sourcePos)
-      val select = checkValue(assignType(cpy.Select(tree)(qual, tree.name), qual), pt)
+      val select = assignType(cpy.Select(tree)(qual, tree.name), qual)
       if (select.tpe ne TryDynamicCallType) ConstFold(checkStableIdentPattern(select, pt))
       else if (pt.isInstanceOf[FunOrPolyProto] || pt == AssignProto) select
       else typedDynamicSelect(tree, Nil, pt)

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -7,7 +7,7 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Types.WildcardType
 import dotty.tools.dotc.parsing.Tokens
 import dotty.tools.dotc.reporting.diagnostic.messages._
-import dotty.tools.dotc.transform.{CheckStatic, PostTyper, TailRec}
+import dotty.tools.dotc.transform.{CheckStatic, Erasure, PostTyper, TailRec}
 import dotty.tools.dotc.typer.{FrontEnd, RefChecks}
 import org.junit.Assert._
 import org.junit.Test
@@ -1475,22 +1475,6 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       assertEquals("class Object", parentSym.show)
     }
 
-  @Test def javaSymbolIsNotAValue =
-    checkMessagesAfter(CheckStatic.name) {
-      """
-        |package p
-        |object O {
-        |  val v = p
-        |}
-      """.stripMargin
-    }.expect { (itcx, messages) =>
-      implicit val ctx: Context = itcx
-
-      assertMessageCount(1, messages)
-      val JavaSymbolIsNotAValue(symbol) = messages.head
-      assertEquals(symbol.show, "package p")
-    }
-
   @Test def i3187 =
     checkMessagesAfter(GenBCode.name) {
       """

tests/fuzzy/parser-stability-15.scala

@@ -0,0 +1,6 @@
+package x0
+class x0 {
+def x1 =
+x2 match
+]
+case x3[] => x0