Change is volatile

src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -131,7 +131,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
 
   val hashMethodSym: Symbol = NoSymbol // used to dispatch ## on primitives to ScalaRuntime.hash. Should be implemented by a miniphase
   val externalEqualsNumNum: Symbol = defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumNum)
-  lazy val externalEqualsNumChar: Symbol = ??? // ctx.requiredMethod(BoxesRunTimeTypeRef, nme.equalsNumChar) // this method is private
+  val externalEqualsNumChar: Symbol = NoSymbol // ctx.requiredMethod(BoxesRunTimeTypeRef, nme.equalsNumChar) // this method is private
   val externalEqualsNumObject: Symbol = defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumObject)
   val externalEquals: Symbol = defn.BoxesRunTimeClass.info.decl(nme.equals_).suchThat(toDenot(_).info.firstParamTypes.size == 2).symbol
   val MaxFunctionArity: Int = Definitions.MaxFunctionArity

src/dotty/tools/dotc/core/CheckRealizable.scala

@@ -0,0 +1,146 @@
+package dotty.tools
+package dotc
+package core
+
+import Contexts._, Types._, Symbols._, Names._, Flags._, Scopes._
+import SymDenotations._, Denotations.SingleDenotation
+import config.Printers._
+import util.Positions._
+import Decorators._
+import StdNames._
+import Annotations._
+import collection.mutable
+import ast.tpd._
+
+/** Realizability status */
+object CheckRealizable {
+
+  abstract class Realizability(val msg: String) {
+    def andAlso(other: => Realizability) =
+      if (this == Realizable) other else this
+    def mapError(f: Realizability => Realizability) =
+      if (this == Realizable) this else f(this)
+  }
+
+  object Realizable extends Realizability("")
+
+  object NotConcrete extends Realizability(" is not a concrete type")
+
+  object NotStable extends Realizability(" is not a stable reference")
+
+  class NotFinal(sym: Symbol)(implicit ctx: Context)
+  extends Realizability(i" refers to nonfinal $sym")
+
+  class HasProblemBounds(typ: SingleDenotation)(implicit ctx: Context)
+  extends Realizability(i" has a member $typ with possibly conflicting bounds ${typ.info.bounds.lo} <: ... <: ${typ.info.bounds.hi}")
+
+  class HasProblemField(fld: SingleDenotation, problem: Realizability)(implicit ctx: Context)
+  extends Realizability(i" has a member $fld which is not a legal path\n since ${fld.symbol.name}: ${fld.info}${problem.msg}")
+
+  class ProblemInUnderlying(tp: Type, problem: Realizability)(implicit ctx: Context)
+  extends Realizability(i"s underlying type ${tp}${problem.msg}") {
+    assert(problem != Realizable)
+  }
+
+  def realizability(tp: Type)(implicit ctx: Context) =
+    new CheckRealizable().realizability(tp)
+
+  def boundsRealizability(tp: Type)(implicit ctx: Context) =
+    new CheckRealizable().boundsRealizability(tp)
+}
+
+/** Compute realizability status */
+class CheckRealizable(implicit ctx: Context) {
+  import CheckRealizable._
+
+  /** A set of all fields that have already been checked. Used
+   *  to avoid infinite recursions when analyzing recursive types.
+   */
+  private val checkedFields: mutable.Set[Symbol] = mutable.LinkedHashSet[Symbol]()
+
+  /** Is symbol's definitition a lazy val?
+   *  (note we exclude modules here, because their realizability is ensured separately)
+   */
+  private def isLateInitialized(sym: Symbol) = sym.is(Lazy, butNot = Module)
+
+  /** Is this type a path with some part that is initialized on use?
+   */
+  private def isLateInitialized(tp: Type): Boolean = tp.dealias match {
+    case tp: TermRef =>
+      isLateInitialized(tp.symbol) || isLateInitialized(tp.prefix)
+    case _: SingletonType | NoPrefix =>
+      false
+    case tp: TypeRef =>
+      true
+    case tp: TypeProxy =>
+      isLateInitialized(tp.underlying)
+    case tp: AndOrType =>
+      isLateInitialized(tp.tp1) || isLateInitialized(tp.tp2)
+    case _ =>
+      true
+  }
+
+  /** The realizability status of given type `tp`*/
+  def realizability(tp: Type): Realizability = tp.dealias match {
+    case tp: TermRef =>
+      val sym = tp.symbol
+      if (sym.is(Stable)) realizability(tp.prefix)
+      else {
+        val r =
+          if (!sym.isStable) NotStable
+          else if (!isLateInitialized(sym)) realizability(tp.prefix)
+          else if (!sym.isEffectivelyFinal) new NotFinal(sym)
+          else realizability(tp.info).mapError(r => new ProblemInUnderlying(tp.info, r))
+        if (r == Realizable) sym.setFlag(Stable)
+        r
+      }
+    case _: SingletonType | NoPrefix =>
+      Realizable
+    case tp =>
+      def isConcrete(tp: Type): Boolean = tp.dealias match {
+        case tp: TypeRef => tp.symbol.isClass
+        case tp: TypeProxy => isConcrete(tp.underlying)
+        case tp: AndOrType => isConcrete(tp.tp1) && isConcrete(tp.tp2)
+        case _ => false
+      }
+      if (!isConcrete(tp)) NotConcrete
+      else boundsRealizability(tp).andAlso(memberRealizability(tp))
+  }
+
+  /** `Realizable` if `tp` has good bounds, a `HasProblemBounds` instance
+   *  pointing to a bad bounds member otherwise.
+   */
+  private def boundsRealizability(tp: Type) = {
+    def hasBadBounds(mbr: SingleDenotation) = {
+      val bounds = mbr.info.bounds
+      !(bounds.lo <:< bounds.hi)
+    }
+    tp.nonClassTypeMembers.find(hasBadBounds) match {
+      case Some(mbr) => new HasProblemBounds(mbr)
+      case _ => Realizable
+    }
+  }
+
+  /** `Realizable` if `tp` all of `tp`'s non-struct fields have realizable types,
+   *  a `HasProblemField` instance pointing to a bad field otherwise.
+   */
+  private def memberRealizability(tp: Type) = {
+    def checkField(sofar: Realizability, fld: SingleDenotation): Realizability =
+      sofar andAlso {
+        if (checkedFields.contains(fld.symbol) || fld.symbol.is(Private | Mutable | Lazy))
+          Realizable
+        else {
+          checkedFields += fld.symbol
+          realizability(fld.info).mapError(r => new HasProblemField(fld, r))
+        }
+      }
+    if (ctx.settings.strict.value)
+      // check fields only under strict mode for now.
+      // Reason: An embedded field could well be nullable, which means it
+      // should not be part of a path and need not be checked; but we cannot recognize
+      // this situation until we have a typesystem that tracks nullability.
+      ((Realizable: Realizability) /: tp.fields)(checkField)
+    else
+      Realizable
+  }
+}

src/dotty/tools/dotc/core/Contexts.scala

@@ -493,7 +493,7 @@ object Contexts {
   }
 
   @sharable object NoContext extends Context {
-    lazy val base = unsupported("base")
+    val base = null
     override val implicits: ContextualImplicits = new ContextualImplicits(Nil, null)(this)
   }
 

src/dotty/tools/dotc/core/Flags.scala

@@ -300,7 +300,7 @@ object Flags {
    */
   final val Abstract = commonFlag(23, "abstract")
 
-  /** Method is assumed to be stable */
+  /** Lazy val or method is known or assumed to be stable and realizable */
   final val Stable = termFlag(24, "<stable>")
 
   /** A case parameter accessor */

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -12,6 +12,7 @@ import scala.reflect.io.AbstractFile
 import Decorators.SymbolIteratorDecorator
 import ast._
 import annotation.tailrec
+import CheckRealizable._
 import typer.Mode
 import util.SimpleMap
 import util.Stats
@@ -519,15 +520,8 @@ object SymDenotations {
       )
 
     /** Is this a denotation of a stable term (or an arbitrary type)? */
-    final def isStable(implicit ctx: Context) = {
-      val isUnstable =
-        (this is UnstableValue) ||
-        ctx.isVolatile(info) && !hasAnnotation(defn.UncheckedStableAnnot)
-      (this is Stable) || isType || {
-        if (isUnstable) false
-        else { setFlag(Stable); true }
-      }
-    }
+    final def isStable(implicit ctx: Context) =
+      isType || is(Stable) || !(is(UnstableValue) || info.isInstanceOf[ExprType])
 
     /** Is this a "real" method? A real method is a method which is:
      *  - not an accessor
@@ -816,14 +810,11 @@ object SymDenotations {
       enclClass(symbol, false)
     }
 
-    final def isEffectivelyFinal(implicit ctx: Context): Boolean = {
-      (this.flags is Flags.PrivateOrFinal) || (!this.owner.isClass) ||
-        ((this.owner.flags is (Flags.ModuleOrFinal)) && (!this.flags.is(Flags.MutableOrLazy))) ||
-        (this.owner.isAnonymousClass)
-    }
+    /** A symbol is effectively final if it cannot be overridden in a subclass */
+    final def isEffectivelyFinal(implicit ctx: Context): Boolean =
+      is(PrivateOrFinal) || !owner.isClass || owner.is(ModuleOrFinal) || owner.isAnonymousClass
 
-    /** The class containing this denotation which has the given effective name.
-     */
+    /** The class containing this denotation which has the given effective name. */
     final def enclosingClassNamed(name: Name)(implicit ctx: Context): Symbol = {
       val cls = enclosingClass
       if (cls.effectiveName == name || !cls.exists) cls else cls.owner.enclosingClassNamed(name)

src/dotty/tools/dotc/core/TypeOps.scala

@@ -3,7 +3,7 @@ package dotc
 package core
 
 import Contexts._, Types._, Symbols._, Names._, Flags._, Scopes._
-import SymDenotations._, Denotations.Denotation
+import SymDenotations._, Denotations.SingleDenotation
 import config.Printers._
 import util.Positions._
 import Decorators._
@@ -341,96 +341,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     }
   }
 
-  /** A type is volatile if its DNF contains an alternative of the form
-   *  {P1, ..., Pn}, {N1, ..., Nk}, where the Pi are parent typerefs and the
-   *  Nj are refinement names, and one the 4 following conditions is met:
-   *
-   *  1. At least two of the parents Pi are abstract types.
-   *  2. One of the parents Pi is an abstract type, and one other type Pj,
-   *     j != i has an abstract member which has the same name as an
-   *     abstract member of the whole type.
-   *  3. One of the parents Pi is an abstract type, and one of the refinement
-   *     names Nj refers to an abstract member of the whole type.
-   *  4. One of the parents Pi is an an alias type with a volatile alias
-   *     or an abstract type with a volatile upper bound.
-   *
-   *  Lazy values are not allowed to have volatile type, as otherwise
-   *  unsoundness can result.
-   */
-  final def isVolatile(tp: Type): Boolean = {
-
-    /** Pre-filter to avoid expensive DNF computation
-     *  If needsChecking returns false it is guaranteed that
-     *  DNF does not contain intersections, or abstract types with upper
-     *  bounds that themselves need checking.
-     */
-    def needsChecking(tp: Type, isPart: Boolean): Boolean = tp match {
-      case tp: TypeRef =>
-        tp.info match {
-          case TypeAlias(alias) =>
-            needsChecking(alias, isPart)
-          case TypeBounds(lo, hi) =>
-            isPart || tp.controlled(isVolatile(hi))
-          case _ => false
-        }
-      case tp: RefinedType =>
-        needsChecking(tp.parent, true)
-      case tp: TypeProxy =>
-        needsChecking(tp.underlying, isPart)
-      case tp: AndType =>
-        true
-      case tp: OrType =>
-        isPart || needsChecking(tp.tp1, isPart) && needsChecking(tp.tp2, isPart)
-      case _ =>
-        false
-    }
-
-    needsChecking(tp, false) && {
-      DNF(tp) forall { case (parents, refinedNames) =>
-        val absParents = parents filter (_.symbol is Deferred)
-        absParents.nonEmpty && {
-          absParents.lengthCompare(2) >= 0 || {
-            val ap = absParents.head
-            ((parents exists (p =>
-              (p ne ap)
-              || p.memberNames(abstractTypeNameFilter, tp).nonEmpty
-              || p.memberNames(abstractTermNameFilter, tp).nonEmpty))
-            || (refinedNames & tp.memberNames(abstractTypeNameFilter, tp)).nonEmpty
-            || (refinedNames & tp.memberNames(abstractTermNameFilter, tp)).nonEmpty
-            || isVolatile(ap))
-          }
-        }
-      }
-    }
-  }
-
-  /** The disjunctive normal form of this type.
-   *  This collects a set of alternatives, each alternative consisting
-   *  of a set of typerefs and a set of refinement names. Both sets are represented
-   *  as lists, to obtain a deterministic order. Collected are
-   *  all type refs reachable by following aliases and type proxies, and
-   *  collecting the elements of conjunctions (&) and disjunctions (|).
-   *  The set of refinement names in each alternative
-   *  are the set of names in refinement types encountered during the collection.
-   */
-  final def DNF(tp: Type): List[(List[TypeRef], Set[Name])] = ctx.traceIndented(s"DNF($this)", checks) {
-    tp.dealias match {
-      case tp: TypeRef =>
-        (tp :: Nil, Set[Name]()) :: Nil
-      case RefinedType(parent, name) =>
-        for ((ps, rs) <- DNF(parent)) yield (ps, rs + name)
-      case tp: TypeProxy =>
-        DNF(tp.underlying)
-      case AndType(l, r) =>
-        for ((lps, lrs) <- DNF(l); (rps, rrs) <- DNF(r))
-          yield (lps | rps, lrs | rrs)
-      case OrType(l, r) =>
-        DNF(l) | DNF(r)
-      case tp =>
-        TypeOps.emptyDNF
-    }
-  }
-
   private def enterArgBinding(formal: Symbol, info: Type, cls: ClassSymbol, decls: Scope) = {
     val lazyInfo = new LazyType { // needed so we do not force `formal`.
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
@@ -644,10 +554,8 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     if (scala2Mode) migrationWarning(msg, pos)
     scala2Mode
   }
-
 }
 
 object TypeOps {
-  val emptyDNF = (Nil, Set[Name]()) :: Nil
   @sharable var track = false // !!!DEBUG
 }

src/dotty/tools/dotc/core/Types.scala

@@ -573,6 +573,12 @@ object Types {
           (name, buf) => buf += member(name).asSingleDenotation)
     }
 
+    /** The set of abstract type members of this type. */
+    final def nonClassTypeMembers(implicit ctx: Context): Seq[SingleDenotation] = track("nonClassTypeMembers") {
+      memberDenots(nonClassTypeNameFilter,
+          (name, buf) => buf += member(name).asSingleDenotation)
+    }
+
     /** The set of type members of this type */
     final def typeMembers(implicit ctx: Context): Seq[SingleDenotation] = track("typeMembers") {
       memberDenots(typeNameFilter,
@@ -3368,6 +3374,15 @@ object Types {
       }
   }
 
+  /** A filter for names of abstract types of a given type */
+  object nonClassTypeNameFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean =
+      name.isTypeName && {
+        val mbr = pre.member(name)
+        mbr.symbol.isType && !mbr.symbol.isClass
+      }
+  }
+
   /** A filter for names of deferred term definitions of a given type */
   object abstractTermNameFilter extends NameFilter {
     def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean =

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

@@ -101,7 +101,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
     case tree: TypeTree => tree
     case _ =>
       if (tree.isType) {
-        Checking.boundsChecker.traverse(tree)
+        Checking.typeChecker.traverse(tree)
         TypeTree(tree.tpe).withPos(tree.pos)
       }
       else tree.tpe.widenTermRefExpr match {
@@ -180,7 +180,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
           val tree1 =
             if (sym.isClass) tree
             else {
-              Checking.boundsChecker.traverse(tree.rhs)
+              Checking.typeChecker.traverse(tree.rhs)
               cpy.TypeDef(tree)(rhs = TypeTree(tree.symbol.info))
             }
           super.transform(tree1)