From d058f98ddc5790b5b3050f6dd10d5d4c84d4eda6 Mon Sep 17 00:00:00 2001 From: Guillaume Martres Date: Mon, 23 Mar 2015 23:16:17 +0100 Subject: Fix isNullableClass to also work after Erasure Incidentally this means that: val d = null.asInstanceOf[Double] is now correctly transformed to: val d = scala.Double.unbox(null) Previously it was translated to: val d = null: Double Which is wrong and fails in the backend. --- src/dotty/tools/dotc/core/SymDenotations.scala | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) (limited to 'src/dotty/tools/dotc/core/SymDenotations.scala') diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala index 44629c036..62e9ab0d2 100644 --- a/src/dotty/tools/dotc/core/SymDenotations.scala +++ b/src/dotty/tools/dotc/core/SymDenotations.scala @@ -496,13 +496,18 @@ object SymDenotations { */ def derivesFrom(base: Symbol)(implicit ctx: Context) = false - /** Is this symbol a class that does not extend `AnyVal`? */ - final def isNonValueClass(implicit ctx: Context): Boolean = - isClass && !derivesFrom(defn.AnyValClass) && (symbol ne defn.NothingClass) + /** Is this symbol a class that extends `AnyVal`? */ + final def isValueClass(implicit ctx: Context): Boolean = { + val di = this.initial.asSymDenotation + di.isClass && + di.derivesFrom(defn.AnyValClass)(ctx.withPhase(di.validFor.firstPhaseId)) + // We call derivesFrom at the initial phase both because AnyVal does not exist + // after Erasure and to avoid cyclic references caused by forcing denotations + } /** Is this symbol a class references to which that are supertypes of null? */ final def isNullableClass(implicit ctx: Context): Boolean = - isNonValueClass && !(this is ModuleClass) + isClass && !isValueClass && !(this is ModuleClass) /** Is this definition accessible as a member of tree with type `pre`? * @param pre The type of the tree from which the selection is made -- cgit v1.2.3