Rename SymDenotation.isStable to SymDenotation.isStableMember

This reduces confusion with `Type.isStable`. I'm tempted to call this `isPure`.

Author: Blaisorblade

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -399,7 +399,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    */
   private def refPurity(tree: Tree)(implicit ctx: Context): PurityLevel =
     if (!tree.tpe.widen.isParameterless || tree.symbol.is(Erased)) SimplyPure
-    else if (!tree.symbol.isStable) Impure
+    else if (!tree.symbol.isStableMember) Impure
     else if (tree.symbol.is(Lazy)) Idempotent // TODO add Module flag, sinxce Module vals or not Lazy from the start.
     else SimplyPure
 
@@ -462,7 +462,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       case tpe: PolyType => maybeGetterType(tpe.resultType)
       case _ => false
     }
-    sym.owner.isClass && !sym.isStable && maybeGetterType(sym.info)
+    sym.owner.isClass && !sym.isStableMember && maybeGetterType(sym.info)
   }
 
   /** Is tree a reference to a mutable variable, or to a potential getter

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

@@ -86,7 +86,7 @@ class CheckRealizable(implicit ctx: Context) {
           r.mapError(if (tp.info.isStableRealizable) Realizable else _)
         val r =
           // Reject fields that are mutable, by-name, and similar.
-          if (!sym.isStable)
+          if (!sym.isStableMember)
             patchRealizability(NotStable)
             // 3. If the symbol isn't "lazy" and its prefix is realizable
           else if (!isLateInitialized(sym)) {

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

@@ -599,7 +599,7 @@ object SymDenotations {
       )
 
     /** Is this a denotation of a stable term (or an arbitrary type)? */
-    final def isStable(implicit ctx: Context) = {
+    final def isStableMember(implicit ctx: Context) = {
       def isUnstableValue = is(UnstableValue) || info.isInstanceOf[ExprType]
       isType || is(Stable) || !isUnstableValue
     }

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

@@ -148,7 +148,7 @@ object Types {
 
     /** Does this type denote a stable reference (i.e. singleton type)? */
     final def isStable(implicit ctx: Context): Boolean = stripTypeVar match {
-      case tp: TermRef => tp.termSymbol.isStable && tp.prefix.isStable || tp.info.isStable
+      case tp: TermRef => tp.termSymbol.isStableMember && tp.prefix.isStable || tp.info.isStable
       case _: SingletonType | NoPrefix => true
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
@@ -960,7 +960,7 @@ object Types {
     /** Widen type if it is unstable (i.e. an ExprType, or TermRef to unstable symbol */
     final def widenIfUnstable(implicit ctx: Context): Type = stripTypeVar match {
       case tp: ExprType => tp.resultType.widenIfUnstable
-      case tp: TermRef if !tp.symbol.isStable => tp.underlying.widenIfUnstable
+      case tp: TermRef if !tp.symbol.isStableMember => tp.underlying.widenIfUnstable
       case _ => this
     }
 

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -278,7 +278,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
     } else if (sym.is(Mutable, butNot = Accessor)) {
       new api.Var(apiType(sym.info), sym.name.toString,
         apiAccess(sym), apiModifiers(sym), apiAnnotations(sym).toArray)
-    } else if (sym.isStable) {
+    } else if (sym.isStableMember) {
       new api.Val(apiType(sym.info), sym.name.toString,
         apiAccess(sym), apiModifiers(sym), apiAnnotations(sym).toArray)
     } else {

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

@@ -59,7 +59,7 @@ class Getters extends MiniPhase with SymTransformer {
       d.hasAnnotation(defn.ScalaStaticAnnot) ||
       d.isSelfSym
     if (d.isTerm && (d.is(Lazy) || d.owner.isClass) && d.info.isValueType && !noGetterNeeded) {
-      val maybeStable = if (d.isStable) Stable else EmptyFlags
+      val maybeStable = if (d.isStableMember) Stable else EmptyFlags
       d.copySymDenotation(
         initFlags = d.flags | maybeStable | AccessorCreationFlags,
         info = ExprType(d.info))

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

@@ -367,7 +367,7 @@ object RefChecks {
         intersectionIsEmpty(member.extendedOverriddenSymbols, other.extendedOverriddenSymbols)) {
         overrideError("cannot override a concrete member without a third member that's overridden by both " +
           "(this rule is designed to prevent ``accidental overrides'')")
-      } else if (other.isStable && !member.isStable) { // (1.4)
+      } else if (other.isStableMember && !member.isStableMember) { // (1.4)
         overrideError("needs to be a stable, immutable value")
       } else if (member.is(ModuleVal) && !other.isRealMethod && !other.is(Deferred | Lazy)) {
         overrideError("may not override a concrete non-lazy value")