Rename Symbol#name to symName

odersky · odersky · commit c2f296280f49 · 2021-01-23T22:22:29.000+01:00
This is to avoid polymorphic dispatch on name once Symbols are subtypes
of SymDenotations
diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
@@ -661,7 +661,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
      */
     private def makeStatifiedDefDef(dd: DefDef): DefDef =
       val origSym = dd.symbol.asTerm
-      val newSym = makeStatifiedDefSymbol(origSym, origSym.name)
+      val newSym = makeStatifiedDefSymbol(origSym, origSym.symName)
       tpd.DefDef(newSym, { paramRefss =>
         val selfParamRef :: regularParamRefs = paramRefss.head
         val enclosingClass = origSym.owner.asClass
diff --git a/compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala b/compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala
@@ -236,7 +236,7 @@ final class JSDefinitions()(using Context) {
 
   /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
   private def scalajsClassName(cls: Symbol)(using Context): TypeName =
-    if (cls.isClass && cls.owner == ScalaJSJSPackageClass) cls.asClass.name
+    if (cls.isClass && cls.owner == ScalaJSJSPackageClass) cls.name.asTypeName
     else EmptyTypeName
 
   /** Is the given `cls` a class of the form `scala.scalajs.js.prefixN` where
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -133,7 +133,7 @@ object desugar {
   /** A derived type definition watching `sym` */
   def derivedTypeParamWithVariance(sym: TypeSymbol)(using Context): TypeDef =
     val variance = VarianceFlags & sym.flags
-    TypeDef(sym.name, DerivedFromParamTree().watching(sym)).withFlags(TypeParam | Synthetic | variance)
+    TypeDef(sym.symName, DerivedFromParamTree().watching(sym)).withFlags(TypeParam | Synthetic | variance)
 
   /** A value definition copied from `vdef` with a tpt typetree derived from it */
   def derivedTermParam(vdef: ValDef)(using Context): ValDef =
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -201,7 +201,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   }
 
   def ValDef(sym: TermSymbol, rhs: LazyTree = EmptyTree)(using Context): ValDef =
-    ta.assignType(untpd.ValDef(sym.name, TypeTree(sym.info), rhs), sym)
+    ta.assignType(untpd.ValDef(sym.symName, TypeTree(sym.info), rhs), sym)
 
   def SyntheticValDef(name: TermName, rhs: Tree)(using Context): ValDef =
     ValDef(newSymbol(ctx.owner, name, Synthetic, rhs.tpe.widen, coord = rhs.span), rhs)
@@ -211,7 +211,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     sym.setParamss(paramss)
     ta.assignType(
       untpd.DefDef(
-        sym.name,
+        sym.symName,
         paramss.map {
           case TypeSymbols(params) => params.map(param => TypeDef(param).withSpan(param.span))
           case TermSymbols(params) => params.map(param => ValDef(param).withSpan(param.span))
@@ -284,7 +284,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   end DefDef
 
   def TypeDef(sym: TypeSymbol)(using Context): TypeDef =
-    ta.assignType(untpd.TypeDef(sym.name, TypeTree(sym.info)), sym)
+    ta.assignType(untpd.TypeDef(sym.symName, TypeTree(sym.info)), sym)
 
   def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree], superArgs: List[Tree] = Nil)(using Context): TypeDef = {
     val firstParent :: otherParents = cls.info.parents
@@ -320,7 +320,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       .orElse(newLocalDummy(cls))
     val impl = untpd.Template(constr, parents, Nil, selfType, newTypeParams ++ body)
       .withType(localDummy.termRef)
-    ta.assignType(untpd.TypeDef(cls.name, impl), cls)
+    ta.assignType(untpd.TypeDef(cls.symName, impl), cls)
   }
 
   /** An anonymous class
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -1679,7 +1679,7 @@ class Definitions {
   def isValueSubType(tref1: TypeRef, tref2: TypeRef)(using Context): Boolean =
     valueTypeEnc(tref2.name) % valueTypeEnc(tref1.name) == 0
   def isValueSubClass(sym1: Symbol, sym2: Symbol): Boolean =
-    valueTypeEnc(sym2.asClass.name) % valueTypeEnc(sym1.asClass.name) == 0
+    valueTypeEnc(sym2.name.asTypeName) % valueTypeEnc(sym1.name.asTypeName) == 0
 
   @tu lazy val specialErasure: SimpleIdentityMap[Symbol, ClassSymbol] =
     SimpleIdentityMap.empty[Symbol]
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -115,7 +115,7 @@ object Symbols:
 
     def isStatic(using Context): Boolean
 
-    def name(using Context): ThisName
+    def symName(using Context): ThisName
     def signature(using Context): Signature
 
     def span: Span
@@ -387,7 +387,7 @@ object Symbols:
     def filter(p: Symbol => Boolean): Symbol = if (p(this.fromSymbolImpl)) this.fromSymbolImpl else NoSymbol
 
     /** The current name of this symbol */
-    final def name(using Context): ThisName = denot.name.asInstanceOf[ThisName]
+    final def symName(using Context): ThisName = denot.name.asInstanceOf[ThisName]
 
     /** The source or class file from which this class or
      *  the class containing this symbol was generated, null if not applicable.
@@ -471,7 +471,7 @@ object Symbols:
 
     // ParamInfo types and methods
     def isTypeParam(using Context): Boolean = denot.is(TypeParam)
-    def paramName(using Context): ThisName = name.asInstanceOf[ThisName]
+    def paramName(using Context): ThisName = symName
     def paramInfo(using Context): Type = denot.info
     def paramInfoAsSeenFrom(pre: Type)(using Context): Type = pre.memberInfo(this.fromSymbolImpl)
     def paramInfoOrCompleter(using Context): Type = denot.infoOrCompleter
@@ -607,7 +607,7 @@ object Symbols:
      */
     def copy(
         owner: Symbol = sym.owner,
-        name: N = sym.name,
+        name: N = sym.symName,
         flags: FlagSet = sym.flags,
         info: Type = sym.info,
         privateWithin: Symbol = sym.privateWithin,
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -736,7 +736,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   private def Modifiers(sym: Symbol): Modifiers = untpd.Modifiers(
     sym.flags & (if (sym.isType) ModifierFlags | VarianceFlags else ModifierFlags),
-    if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
+    if (sym.privateWithin.exists) sym.privateWithin.name.asTypeName else tpnme.EMPTY,
     sym.annotations.filterNot(ann => dropAnnotForModText(ann.symbol)).map(_.tree))
 
   protected def dropAnnotForModText(sym: Symbol): Boolean = sym == defn.BodyAnnot
diff --git a/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala b/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala
@@ -106,7 +106,7 @@ abstract class AccessProxies {
       case getterRef: RefTree =>
         val getter = getterRef.symbol.asTerm
         val accessed = accessedBy(getter)
-        val setterName = getter.name.setterName
+        val setterName = getter.symName.setterName
         def toSetterInfo(getterInfo: Type): Type = getterInfo match {
           case getterInfo: LambdaType =>
             getterInfo.derivedLambdaType(resType = toSetterInfo(getterInfo.resType))
@@ -134,7 +134,7 @@ abstract class AccessProxies {
       if (accessorClass.exists) {
         if accessorClass.is(Package) then
           accessorClass = ctx.owner.topLevelClass
-        val accessorName = accessorNameKind(accessed.name)
+        val accessorName = accessorNameKind(accessed.symName)
         val accessorInfo =
           accessed.info.ensureMethodic.asSeenFrom(accessorClass.thisType, accessed.owner)
         val accessor = accessorSymbol(accessorClass, accessorName, accessorInfo, accessed)
diff --git a/compiler/src/dotty/tools/dotc/transform/Constructors.scala b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
@@ -225,7 +225,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
                 if sym.setter.exists then
                   sym.setter
                 else
-                  val setterName = sym.asTerm.name.setterName
+                  val setterName = sym.name.asTermName.setterName
                   sym.owner.info.decls.find(d => d.is(Accessor) && d.name == setterName)
               val setter =
                 if (symSetter.exists) symSetter
diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala
@@ -56,7 +56,7 @@ class ExpandSAMs extends MiniPhase:
           val tpe1 = checkRefinements(tpe, fn)
           val Seq(samDenot) = tpe1.possibleSamMethods
           cpy.Block(tree)(stats,
-              AnonClass(tpe1 :: Nil, fn.symbol.asTerm :: Nil, samDenot.symbol.asTerm.name :: Nil))
+              AnonClass(tpe1 :: Nil, fn.symbol.asTerm :: Nil, samDenot.symbol.name.asTermName :: Nil))
       }
     case _ =>
       tree
diff --git a/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala b/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala
@@ -97,7 +97,7 @@ trait FullParameterization {
       case _ => (0, info)
     }
     val ctparams = if (abstractOverClass) clazz.typeParams else Nil
-    val ctnames = ctparams.map(_.name)
+    val ctnames = ctparams.map(_.symName)
 
     /** The method result type */
     def resultType(mapClassParams: Type => Type) = {
diff --git a/compiler/src/dotty/tools/dotc/transform/Getters.scala b/compiler/src/dotty/tools/dotc/transform/Getters.scala
@@ -96,7 +96,7 @@ class Getters extends MiniPhase with SymTransformer { thisPhase =>
   def ensureSetter(sym: TermSymbol)(using Context) =
     if !sym.setter.exists then
       newSetters += sym.copy(
-        name = sym.name.setterName,
+        name = sym.symName.setterName,
         info = MethodType(sym.info.widenExpr :: Nil, defn.UnitType)
       ).enteredAfter(thisPhase)
 
diff --git a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
@@ -298,10 +298,10 @@ object LambdaLift {
 
     private def newName(sym: Symbol)(using Context): Name =
       if (sym.isAnonymousFunction && sym.owner.is(Method))
-        sym.name.replace {
+        sym.symName.replace {
           case name: SimpleName => ExpandPrefixName(sym.owner.name.asTermName, name)
         }.freshened
-      else sym.name.freshened
+      else sym.symName.freshened
 
     private def generateProxies()(using Context): Unit =
       for ((owner, freeValues) <- free.iterator) {
diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -125,7 +125,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     */
   def transformSyntheticModule(tree: ValOrDefDef)(using Context): Thicket = {
     val sym = tree.symbol
-    val holderSymbol = newSymbol(sym.owner, LazyLocalName.fresh(sym.asTerm.name),
+    val holderSymbol = newSymbol(sym.owner, LazyLocalName.fresh(sym.name.asTermName),
       Synthetic, sym.info.widen.resultType).enteredAfter(this)
     val field = ValDef(holderSymbol, tree.rhs.changeOwnerAfter(sym, holderSymbol, this))
     val getter = DefDef(sym.asTerm, ref(holderSymbol))
diff --git a/compiler/src/dotty/tools/dotc/transform/MixinOps.scala b/compiler/src/dotty/tools/dotc/transform/MixinOps.scala
@@ -21,7 +21,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
   def mkForwarderSym(member: TermSymbol, extraFlags: FlagSet = EmptyFlags): TermSymbol = {
     val res = member.copy(
       owner = cls,
-      name = member.name.stripScala2LocalSuffix,
+      name = member.symName.stripScala2LocalSuffix,
       flags = member.flags &~ Deferred &~ Module | Synthetic | extraFlags,
       info = cls.thisType.memberInfo(member)).enteredAfter(thisPhase).asTerm
     res.addAnnotations(member.annotations.filter(_.symbol != defn.TailrecAnnot))
diff --git a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
@@ -285,7 +285,7 @@ object PCPCheckAndHeal {
         info = TypeAlias(splicedTree.tpe.select(tpnme.Underlying)),
         coord = span).asType
       local.addAnnotation(Annotation(defn.QuotedRuntime_SplicedTypeAnnot))
-      ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
+      ctx.typeAssigner.assignType(untpd.TypeDef(local.symName, alias), local)
     }
 
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala
@@ -59,7 +59,7 @@ class ParamForwarding extends MiniPhase with IdentityDenotTransformer:
       val alias = atPhase(thisPhase)(inheritedAccessor(sym))
       if alias.exists then
         sym.copySymDenotation(
-            name = ParamAccessorName(sym.name),
+            name = ParamAccessorName(sym.symName),
             initFlags = sym.flags | Method | StableRealizable,
             info = sym.info.ensureMethodic
           ).installAfter(thisPhase)
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -155,11 +155,11 @@ object SymUtils:
       self.info.decls.filter(_.is(CaseAccessor))
 
     def getter(using Context): Symbol =
-      if (self.isGetter) self else accessorNamed(self.asTerm.name.getterName)
+      if (self.isGetter) self else accessorNamed(self.name.asTermName.getterName)
 
     def setter(using Context): Symbol =
       if (self.isSetter) self
-      else accessorNamed(self.asTerm.name.setterName)
+      else accessorNamed(self.name.asTermName.setterName)
 
     def traitSetter(using Context): Symbol =
       if (self.name.is(TraitSetterName)) self
diff --git a/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala b/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala
@@ -97,7 +97,7 @@ object JSSymUtils {
     def isJSDefaultParam(using Context): Boolean = {
       sym.name.is(DefaultGetterName) && {
         val owner = sym.owner
-        val methName = sym.name.exclude(DefaultGetterName)
+        val methName = sym.symName.exclude(DefaultGetterName)
         if (methName == nme.CONSTRUCTOR) {
           owner.linkedClass.isJSType
         } else {
@@ -125,7 +125,7 @@ object JSSymUtils {
     }
 
     def defaultJSName(using Context): String =
-      if (sym.isTerm) sym.asTerm.name.unexpandedName.getterName.toString()
+      if (sym.isTerm) sym.asTerm.symName.unexpandedName.getterName.toString()
       else sym.name.unexpandedName.stripModuleClassSuffix.toString()
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -217,7 +217,7 @@ object Applications {
         }
       }
       val getterPrefix =
-        if (meth.is(Synthetic) && meth.name == nme.apply) nme.CONSTRUCTOR else meth.name
+        if (meth.is(Synthetic) && meth.name == nme.apply) nme.CONSTRUCTOR else meth.symName
       def getterName = DefaultGetterName(getterPrefix, n + numArgs(fn))
       if !meth.hasDefaultParams then
         EmptyTree
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -196,7 +196,7 @@ object Inliner {
     val meth = mdef.symbol.asTerm
 
     val retainer = meth.copy(
-      name = BodyRetainerName(meth.name),
+      name = BodyRetainerName(meth.symName),
       flags = meth.flags &~ (Inline | Macro | Override) | Private,
       coord = mdef.rhs.span.startPos).asTerm
     retainer.deriveTargetNameAnnotation(meth, name => BodyRetainerName(name.asTermName))
diff --git a/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
@@ -156,7 +156,7 @@ object PrepareInlineable {
           val accessedType = refPart.tpe.widen
           val accessor = accessorSymbol(
             owner = inlineSym.owner,
-            accessorName = InlineAccessorName(UniqueInlineName.fresh(accessed.name)),
+            accessorName = InlineAccessorName(UniqueInlineName.fresh(accessed.symName)),
             accessorInfo = abstractQualType(addQualType(dealiasMap(accessedType))),
             accessed = accessed)
 
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2476,7 +2476,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         def exists: Boolean = self != Symbol.noSymbol
 
         def declaredField(name: String): Symbol =
-          val sym = self.unforcedDecls.find(sym => sym.name == name.toTermName)
+          val sym = self.unforcedDecls.find(sym => sym.symName == name.toTermName)
           if (isField(sym)) sym else dotc.core.Symbols.NoSymbol
 
         def declaredFields: List[Symbol] = self.unforcedDecls.filter(isField)
@@ -2522,7 +2522,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           }.toList
 
         def memberType(name: String): Symbol =
-          self.unforcedDecls.find(sym => sym.name == name.toTypeName)
+          self.unforcedDecls.find(sym => sym.symName == name.toTypeName)
 
         def memberTypes: List[Symbol] =
           self.unforcedDecls.filter(_.isType)
diff --git a/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala b/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala
@@ -359,7 +359,7 @@ class DottyLanguageServer extends LanguageServer
 
       perProjectInfo.flatMap { (remoteDriver, ctx, definitions) =>
         definitions.flatMap { definition =>
-          val name = definition.name(using ctx).sourceModuleName.toString
+          val name = definition.symName(using ctx).sourceModuleName.toString
           val trees = remoteDriver.sourceTreesContaining(name)(using ctx)
           val matches = Interactive.findTreesMatching(trees, includes, definition)(using ctx)
           matches.map(tree => location(tree.namePos(using ctx)))

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ class ExpandSAMs extends MiniPhase:`
`56`	`56`	`val tpe1 = checkRefinements(tpe, fn)`
`57`	`57`	`val Seq(samDenot) = tpe1.possibleSamMethods`
`58`	`58`	`cpy.Block(tree)(stats,`
`59`		`- AnonClass(tpe1 :: Nil, fn.symbol.asTerm :: Nil, samDenot.symbol.asTerm.name :: Nil))`
	`59`	`+ AnonClass(tpe1 :: Nil, fn.symbol.asTerm :: Nil, samDenot.symbol.name.asTermName :: Nil))`
`60`	`60`	`}`
`61`	`61`	`case _ =>`
`62`	`62`	`tree`