Allow classOf[Foo.type] if Foo is an object

And use this in SyntheticMethods instead of the
impossible-to-write-in-user-code `classOf[Foo$]`. This is necessary if
we want decompilation to produce valid source code for objects.

Note that the decompilation printer is currently wrong here and will
print `classOf[Foo]` instead of `classOf[Foo.type]`.

Author: smarter

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -471,7 +471,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def toText(const: Constant): Text = const.tag match {
     case StringTag => stringText("\"" + escapedString(const.value.toString) + "\"")
-    case ClazzTag => "classOf[" ~ toText(const.typeValue.classSymbol) ~ "]"
+    case ClazzTag => "classOf[" ~ toText(const.typeValue) ~ "]"
     case CharTag => literalText(s"'${escapedChar(const.charValue)}'")
     case LongTag => literalText(const.longValue.toString + "L")
     case EnumTag => literalText(const.symbolValue.name.toString)

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

@@ -264,7 +264,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
   /** If this is a serializable static object `Foo`, add the method:
    *
    *      private def writeReplace(): AnyRef =
-   *        new scala.runtime.ModuleSerializationProxy(classOf[Foo$])
+   *        new scala.runtime.ModuleSerializationProxy(classOf[Foo.type])
    *
    *  unless an implementation already exists, otherwise do nothing.
    */
@@ -280,7 +280,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
         DefDef(writeReplace,
           _ => New(defn.ModuleSerializationProxyType,
                    defn.ModuleSerializationProxyConstructor,
-                   List(Literal(Constant(clazz.typeRef)))))
+                   List(Literal(Constant(clazz.sourceModule.termRef)))))
           .withSpan(ctx.owner.span.focus))
     }
     else

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

@@ -907,7 +907,8 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
             if (typedArgs.length <= pt.paramInfos.length && !isNamed)
               if (typedFn.symbol == defn.Predef_classOf && typedArgs.nonEmpty) {
                 val arg = typedArgs.head
-                checkClassType(arg.tpe, arg.sourcePos, traitReq = false, stablePrefixReq = false)
+                if (!arg.symbol.is(Module)) // Allow `classOf[Foo.type]` if `Foo` is an object
+                  checkClassType(arg.tpe, arg.sourcePos, traitReq = false, stablePrefixReq = false)
               }
           case _ =>
         }

tests/neg/classOf.scala

@@ -5,7 +5,7 @@ object Test {
 
   def f1[T] = classOf[T] // error
   def f2[T <: String] = classOf[T] // error
-  val x = classOf[Test.type] // error
+  val x = classOf[Test.type] // ok
   val y = classOf[C { type I = String }] // error
   val z = classOf[A] // ok
 }

tests/run/classof-object.scala

@@ -0,0 +1,5 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert(classOf[Test.type] == Test.getClass)
+  }
+}