Rename erasedName -> targetName

Author: odersky

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

@@ -891,7 +891,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
      *  on select(sym: Symbol).
      */
     def selectWithSig(sym: Symbol)(using Context): Tree =
-      selectWithSig(sym.name, sym.signature, sym.erasedName)
+      selectWithSig(sym.name, sym.signature, sym.targetName)
 
     /** A unary apply node with given argument: `tree(arg)` */
     def appliedTo(arg: Tree)(using Context): Apply =

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

@@ -347,12 +347,12 @@ object Denotations {
     }
 
     /** The alternative of this denotation that has a type matching `targetType` when seen
-     *  as a member of type `site` and that has an erased name matching `targetName`, or
+     *  as a member of type `site` and that has a target name matching `targetName`, or
      *  `NoDenotation` if none exists.
      */
     def matchingDenotation(site: Type, targetType: Type, targetName: Name)(using Context): SingleDenotation = {
       def qualifies(sym: Symbol) =
-        site.memberInfo(sym).matchesLoosely(targetType) && targetNamesMatch(sym.erasedName, targetName)
+        site.memberInfo(sym).matchesLoosely(targetType) && targetNamesMatch(sym.targetName, targetName)
       if (isOverloaded)
         atSignature(targetType.signature, targetName, site, relaxed = true) match {
           case sd: SingleDenotation => sd.matchingDenotation(site, targetType, targetName)
@@ -624,7 +624,7 @@ object Denotations {
           relaxed
         case noMatch =>
           false
-      if sigMatches && targetNamesMatch(symbol.erasedName, targetName) then this
+      if sigMatches && targetNamesMatch(symbol.targetName, targetName) then this
       else NoDenotation
 
     def matchesImportBound(bound: Type)(using Context): Boolean =
@@ -986,7 +986,7 @@ object Denotations {
     final def last: SingleDenotation = this
 
     def matches(other: SingleDenotation)(using Context): Boolean =
-      targetNamesMatch(symbol.erasedName, other.symbol.erasedName)
+      targetNamesMatch(symbol.targetName, other.symbol.targetName)
       && {
         val d = signature.matchDegree(other.signature)
         d match

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

@@ -513,7 +513,7 @@ object SymDenotations {
       myTargetName = name
 
     /** The name given in a `@targetName` annotation if one is present, `name` otherwise */
-    def erasedName(using Context): Name =
+    def targetName(using Context): Name =
       if myTargetName == null then
         val carrier: SymDenotation =
           if isAllOf(ModuleClass | Synthetic) then companionClass else this
@@ -1256,7 +1256,7 @@ object SymDenotations {
     final def matchingDecl(inClass: Symbol, site: Type)(using Context): Symbol = {
       var denot = inClass.info.nonPrivateDecl(name)
       if (denot.isTerm) // types of the same name always match
-        denot = denot.matchingDenotation(site, site.memberInfo(symbol), symbol.erasedName)
+        denot = denot.matchingDenotation(site, site.memberInfo(symbol), symbol.targetName)
       denot.symbol
     }
 
@@ -1265,7 +1265,7 @@ object SymDenotations {
     final def matchingMember(site: Type)(using Context): Symbol = {
       var denot = site.nonPrivateMember(name)
       if (denot.isTerm) // types of the same name always match
-        denot = denot.matchingDenotation(site, site.memberInfo(symbol), symbol.erasedName)
+        denot = denot.matchingDenotation(site, site.memberInfo(symbol), symbol.targetName)
       denot.symbol
     }
 
@@ -2336,7 +2336,7 @@ object SymDenotations {
     override def mapInfo(f: Type => Type)(using Context): SingleDenotation = this
 
     override def matches(other: SingleDenotation)(using Context): Boolean = false
-    override def erasedName(using Context): Name = EmptyTermName
+    override def targetName(using Context): Name = EmptyTermName
     override def mapInherited(ownDenots: PreDenotation, prevDenots: PreDenotation, pre: Type)(using Context): SingleDenotation = this
     override def filterWithPredicate(p: SingleDenotation => Boolean): SingleDenotation = this
     override def filterDisjoint(denots: PreDenotation)(using Context): SingleDenotation = this

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

@@ -2084,7 +2084,7 @@ object Types {
     }
 
     private def disambiguate(d: Denotation)(using Context): Denotation =
-      disambiguate(d, currentSignature, currentSymbol.erasedName)
+      disambiguate(d, currentSignature, currentSymbol.targetName)
 
     private def disambiguate(d: Denotation, sig: Signature, target: Name)(using Context): Denotation =
       if (sig != null)
@@ -2396,7 +2396,7 @@ object Types {
           d = disambiguate(d,
                 if (lastSymbol.signature == Signature.NotAMethod) Signature.NotAMethod
                 else lastSymbol.asSeenFrom(prefix).signature,
-                lastSymbol.erasedName)
+                lastSymbol.targetName)
         NamedType(prefix, name, d)
       }
       if (prefix eq this.prefix) this

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -197,14 +197,14 @@ class TreePickler(pickler: TastyPickler) {
         if (sym.is(Flags.Private) || isShadowedRef) {
           writeByte(if (tpe.isType) TYPEREFin else TERMREFin)
           withLength {
-            pickleNameAndSig(sym.name, sym.signature, sym.erasedName)
+            pickleNameAndSig(sym.name, sym.signature, sym.targetName)
             pickleType(tpe.prefix)
             pickleType(sym.owner.typeRef)
           }
         }
         else {
           writeByte(if (tpe.isType) TYPEREF else TERMREF)
-          pickleNameAndSig(sym.name, tpe.signature, sym.erasedName)
+          pickleNameAndSig(sym.name, tpe.signature, sym.targetName)
           pickleType(tpe.prefix)
         }
       }
@@ -405,7 +405,7 @@ class TreePickler(pickler: TastyPickler) {
               }
             case _ =>
               val sig = tree.tpe.signature
-              var ename = tree.symbol.erasedName
+              var ename = tree.symbol.targetName
               val isAmbiguous =
                 sig != Signature.NotAMethod
                 && qual.tpe.nonPrivateMember(name).match

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1086,7 +1086,7 @@ import transform.SymUtils._
   extends DeclarationMsg(OverridesNothingButNameExistsID) {
     def msg =
       val what =
-        if !existing.exists(sd => Denotations.targetNamesMatch(member.erasedName, sd.symbol.erasedName))
+        if !existing.exists(sd => Denotations.targetNamesMatch(member.targetName, sd.symbol.targetName))
         then "target name"
         else "signature"
       em"""${member} has a different $what than the overridden declaration"""

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

@@ -77,7 +77,7 @@ class Erasure extends Phase with DenotTransformer {
         val oldOwner = ref.owner
         val newOwner = if (oldOwner eq defn.AnyClass) defn.ObjectClass else oldOwner
         val oldName = ref.name
-        val newName = ref.erasedName
+        val newName = ref.targetName
         val oldInfo = ref.info
         val newInfo = transformInfo(oldSymbol, oldInfo)
         val oldFlags = ref.flags
@@ -938,7 +938,7 @@ object Erasure {
           val origName = retainer.name.asTermName.exclude(BodyRetainerName)
           val targetName =
             if retainer.hasAnnotation(defn.TargetNameAnnot) then
-              retainer.erasedName.unmangle(BodyRetainerName).exclude(BodyRetainerName)
+              retainer.targetName.unmangle(BodyRetainerName).exclude(BodyRetainerName)
             else origName
           val inlineMeth = atPhase(typerPhase) {
             retainer.owner.info.decl(origName)

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

@@ -91,8 +91,8 @@ object ResolveSuper {
 
     val (memberName, mix) = decomposeSuperName(acc.name.unexpandedName)
     val targetName =
-      if acc.name == acc.erasedName then memberName
-      else decomposeSuperName(acc.erasedName)._1
+      if acc.name == acc.targetName then memberName
+      else decomposeSuperName(acc.targetName)._1
 
     report.debuglog(i"starting rebindsuper from $base of ${acc.showLocated}: ${acc.info} in $bcs, name = $memberName")
 
@@ -112,7 +112,7 @@ object ResolveSuper {
 
       bcs = bcs.tail
     }
-    assert(sym.exists, i"cannot rebind $acc, ${acc.erasedName} $memberName")
+    assert(sym.exists, i"cannot rebind $acc, ${acc.targetName} $memberName")
     sym
   }
 }

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

@@ -266,6 +266,6 @@ object SymUtils:
       if original.hasAnnotation(defn.TargetNameAnnot) then
         self.addAnnotation(
           Annotation(defn.TargetNameAnnot,
-            Literal(Constant(nameFn(original.erasedName).toString)).withSpan(original.span)))
+            Literal(Constant(nameFn(original.targetName).toString)).withSpan(original.span)))
   end extension
 end SymUtils

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

@@ -1208,12 +1208,12 @@ trait Checking {
     var seen = Set[Name]()
     for stat <- stats do
       val sym = stat.symbol
-      val ename = sym.erasedName
-      if ename != sym.name then
-        val preExisting = ctx.effectiveScope.lookup(ename)
-        if preExisting.exists || seen.contains(ename) then
-          report.error(em"@targetName annotation ${'"'}$ename${'"'} clashes with other definition in same scope", stat.srcPos)
-        if stat.isDef then seen += ename
+      val tname = sym.targetName
+      if tname != sym.name then
+        val preExisting = ctx.effectiveScope.lookup(tname)
+        if preExisting.exists || seen.contains(tname) then
+          report.error(em"@targetName annotation ${'"'}$tname${'"'} clashes with other definition in same scope", stat.srcPos)
+        if stat.isDef then seen += tname
 }
 
 trait ReChecking extends Checking {

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

@@ -1298,7 +1298,7 @@ class Namer { typer: Typer =>
                 else NoType
             }
             val iRawInfo =
-              cls.info.nonPrivateDecl(sym.name).matchingDenotation(site, schema, sym.erasedName).info
+              cls.info.nonPrivateDecl(sym.name).matchingDenotation(site, schema, sym.targetName).info
             val iResType = instantiatedResType(iRawInfo, typeParams, paramss).asSeenFrom(site, cls)
             if (iResType.exists)
               typr.println(i"using inherited type for ${mdef.name}; raw: $iRawInfo, inherited: $iResType")

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

@@ -431,9 +431,9 @@ object RefChecks {
       else if (!compatibleTypes(memberTp(self), otherTp(self)) &&
                  !compatibleTypes(memberTp(upwardsSelf), otherTp(upwardsSelf)))
         overrideError("has incompatible type" + err.whyNoMatchStr(memberTp(self), otherTp(self)))
-      else if (member.erasedName != other.erasedName)
-        if (other.erasedName != other.name)
-          overrideError(i"needs to be declared with @targetName(${"\""}${other.erasedName}${"\""}) so that external names match")
+      else if (member.targetName != other.targetName)
+        if (other.targetName != other.name)
+          overrideError(i"needs to be declared with @targetName(${"\""}${other.targetName}${"\""}) so that external names match")
         else
           overrideError("cannot have a @targetName annotation since external names would be different")
       else

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

@@ -1979,8 +1979,7 @@ class Typer extends Namer
       PrepareInlineable.registerInlineInfo(sym, rhsToInline)
 
     if (sym.isConstructor && !sym.isPrimaryConstructor) {
-      val ename = sym.erasedName
-      if (ename != sym.name)
+      if (sym.targetName != sym.name)
         report.error(em"@targetName annotation may not be used on a constructor", ddef.srcPos)
 
       for (param <- tparams1 ::: vparamss1.flatten)