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

@@ -402,7 +402,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
         sym.owner.isPrimitiveValueClass || sym.owner == defn.StringClass
       if (tree.tpe.isInstanceOf[ConstantType] && isKnownPureOp(tree.symbol)
              // A constant expression with pure arguments is pure.
-          || fn.symbol.isStable)
+          || fn.symbol.isStableMember)
         minOf(exprPurity(fn), args.map(exprPurity)) `min` Pure
       else
         Impure
@@ -438,7 +438,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     val sym = tree.symbol
     if (!tree.hasType) Impure
     else if (!tree.tpe.widen.isParameterless || sym.is(Erased)) SimplyPure
-    else if (!sym.isStable) Impure
+    else if (!sym.isStableMember) Impure
     else if (sym.is(Module))
       if (sym.moduleClass.isNoInitsClass) Pure else Idempotent
     else if (sym.is(Lazy)) Idempotent
@@ -504,7 +504,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

@@ -88,7 +88,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

@@ -589,7 +589,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(StableOrErased) || !isUnstableValue
     }

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

@@ -151,7 +151,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
@@ -992,7 +992,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

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

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

@@ -64,7 +64,7 @@ class Getters extends MiniPhase with SymTransformer {
 
     var d1 =
       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/Inliner.scala

@@ -747,7 +747,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
         case tpe: NamedType if tpe.symbol.exists && !tpe.symbol.isAccessibleFrom(tpe.prefix, superAccess) =>
           tpe.info match {
             case TypeAlias(alias) => return ensureAccessible(alias, superAccess, pos)
-            case info: ConstantType if tpe.symbol.isStable => return info
+            case info: ConstantType if tpe.symbol.isStableMember => return info
             case _ =>
           }
         case _ =>

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

@@ -81,7 +81,7 @@ object PrepareTransparent {
         sym.isTerm &&
         (sym.is(AccessFlags) || sym.privateWithin.exists) &&
         !sym.isContainedIn(inlineSym) &&
-        !(sym.isStable && sym.info.widenTermRefExpr.isInstanceOf[ConstantType])
+        !(sym.isStableMember && sym.info.widenTermRefExpr.isInstanceOf[ConstantType])
 
       def preTransform(tree: Tree)(implicit ctx: Context): Tree
 
@@ -438,4 +438,4 @@ object PrepareTransparent {
     val untpdSplice = tpd.UntypedSplice(addRefs.transform(original)).withType(typed.tpe)
     seq(implicitBindings, untpdSplice)
   }
-}
+}

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")