Check classOf argument

The argument must be a class type. Abstract types are not permitted.
Neither are refinement types or termrefs.

classOf translation is now handled in Typer. The extra miniphase
is no longer needed.

Author: odersky

src/dotty/tools/dotc/Compiler.scala

@@ -48,8 +48,7 @@ class Compiler {
            new ExtensionMethods,
            new ExpandSAMs,
            new TailRec,
-           new LiftTry,
-           new ClassOf),
+           new LiftTry),
       List(new PatternMatcher,
            new ExplicitOuter,
            new ExplicitSelf,

src/dotty/tools/dotc/transform/ClassOf.scala

@@ -609,7 +609,13 @@ trait Applications extends Compatibility { self: Typer =>
           typedArgs = typedArgs.zipWithConserve(pt.paramBounds)(adaptTypeArg)
       case _ =>
     }
-    assignType(cpy.TypeApply(tree)(typedFn, typedArgs), typedFn, typedArgs)
+    val res = assignType(cpy.TypeApply(tree)(typedFn, typedArgs), typedFn, typedArgs)
+    if (res.symbol == defn.Predef_classOf) {
+      val arg = res.args.head
+      checkClassType(arg.tpe, arg.pos, traitReq = false, stablePrefixReq = false)
+      clsOf(arg.tpe).withPos(res.pos)
+    }
+    else res
   }
 
   def adaptTypeArg(tree: tpd.Tree, bound: Type)(implicit ctx: Context): tpd.Tree =

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

@@ -344,16 +344,17 @@ trait Checking {
       ctx.error(i"$tp cannot be instantiated since it${rstatus.msg}", pos)
   }
 
- /**  Check that `tp` is a class type with a stable prefix. Also, if `traitReq` is
-   *  true check that `tp` is a trait.
-   *  Stability checking is disabled in phases after RefChecks.
+ /**  Check that `tp` is a class type.
+  *   Also, if `traitReq` is true, check that `tp` is a trait.
+  *   Also, if `stablePrefixReq` is true and phase is not after RefChecks,
+  *   check that class prefix is stable.
    *  @return  `tp` itself if it is a class or trait ref, ObjectType if not.
    */
-  def checkClassTypeWithStablePrefix(tp: Type, pos: Position, traitReq: Boolean)(implicit ctx: Context): Type =
+  def checkClassType(tp: Type, pos: Position, traitReq: Boolean, stablePrefixReq: Boolean)(implicit ctx: Context): Type =
     tp.underlyingClassRef(refinementOK = false) match {
       case tref: TypeRef =>
-        if (ctx.phase <= ctx.refchecksPhase) checkStable(tref.prefix, pos)
         if (traitReq && !(tref.symbol is Trait)) ctx.error(d"$tref is not a trait", pos)
+        if (stablePrefixReq && ctx.phase <= ctx.refchecksPhase) checkStable(tref.prefix, pos)
         tp
       case _ =>
         ctx.error(d"$tp is not a class type", pos)
@@ -456,7 +457,7 @@ trait NoChecking extends Checking {
   override def checkNonCyclic(sym: Symbol, info: TypeBounds, reportErrors: Boolean)(implicit ctx: Context): Type = info
   override def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = tree
   override def checkStable(tp: Type, pos: Position)(implicit ctx: Context): Unit = ()
-  override def checkClassTypeWithStablePrefix(tp: Type, pos: Position, traitReq: Boolean)(implicit ctx: Context): Type = tp
+  override def checkClassType(tp: Type, pos: Position, traitReq: Boolean, stablePrefixReq: Boolean)(implicit ctx: Context): Type = tp
   override def checkImplicitParamsNotSingletons(vparamss: List[List[ValDef]])(implicit ctx: Context): Unit = ()
   override def checkFeasible(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type = tp
   override def checkNoDoubleDefs(cls: Symbol)(implicit ctx: Context): Unit = ()

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

@@ -598,7 +598,8 @@ class Namer { typer: Typer =>
         val ptype = parentType(parent)(ctx.superCallContext)
         if (cls.isRefinementClass) ptype
         else {
-          val pt = checkClassTypeWithStablePrefix(ptype, parent.pos, traitReq = parent ne parents.head)
+          val pt = checkClassType(ptype, parent.pos,
+              traitReq = parent ne parents.head, stablePrefixReq = true)
           if (pt.derivesFrom(cls)) {
             val addendum = parent match {
               case Select(qual: Super, _) if ctx.scala2Mode =>

src/dotty/tools/dotc/typer/Namer.scala

@@ -382,7 +382,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           case TypeApplications.EtaExpansion(tycon) => tpt1 = tpt1.withType(tycon)
           case _ =>
         }
-        checkClassTypeWithStablePrefix(tpt1.tpe, tpt1.pos, traitReq = false)
+        checkClassType(tpt1.tpe, tpt1.pos, traitReq = false, stablePrefixReq = true)
         assignType(cpy.New(tree)(tpt1), tpt1)
         // todo in a later phase: checkInstantiatable(cls, tpt1.pos)
     }