Don't use NotAMethod in SignedNames

Instead, assume that an unsigned name means NotAMethod.

Author: odersky

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

@@ -35,8 +35,10 @@ object Designators {
     def localizeIfPrivate(sym: Symbol)(implicit ctx: Context): Designator { type ThisName = self.ThisName } =
       if (sym.isPrivate) withNameSpace(sym.owner.typeRef) else this
 
-    def withSig(sig: Signature): Designator{ type ThisName = TermName } =
-      SignedName(this.asInstanceOf[TermName].exclude(SignedName), sig)
+    def withSig(sig: Signature): Designator{ type ThisName = TermName } = {
+      val unsigned = this.asInstanceOf[TermName].exclude(SignedName)
+      if (sig eq Signature.NotAMethod) unsigned else SignedName(unsigned, sig)
+    }
   }
 
   type TermDesignator = Designator { type ThisName = TermName }

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

@@ -366,6 +366,7 @@ object NameKinds {
   object SignedName extends NameKind(SIGNED) {
 
     case class SignedInfo(sig: Signature) extends Info {
+      assert(sig ne Signature.NotAMethod)
       override def toString = s"$infoString $sig"
     }
     type ThisInfo = SignedInfo

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

@@ -1509,6 +1509,7 @@ object Types {
           decompose(underlying)
         case designator: Name =>
           myName = designator.asInstanceOf[ThisName]
+          if (mySig == null) mySig = Signature.NotAMethod
         case designator: Symbol =>
           uncheckedSetSym(designator)
         case LocalName(underlying, space) =>
@@ -1524,10 +1525,10 @@ object Types {
       myName
     }
 
-    final override def signature(implicit ctx: Context): Signature =
-      if (mySig != null) mySig
-      else if (isType || lastDenotation == null) Signature.NotAMethod
-      else denot.signature
+    final override def signature(implicit ctx: Context): Signature = {
+      if (mySig == null) mySig = denot.signature
+      mySig
+    }
 
     final def nameSpace: NameSpace = myNameSpace
 
@@ -1974,7 +1975,7 @@ object Types {
         // from the new prefix, modulo consistency
         val curSig = signature
         val newSig =
-          if (curSig == Signature.NotAMethod || !symbol.exists)
+          if (curSig.eq(Signature.NotAMethod) || !symbol.exists)
             curSig
           else
             curSig.updateWith(symbol.info.asSeenFrom(prefix, symbol.owner).signature)

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

@@ -64,8 +64,8 @@ class TastyUnpickler(reader: TastyReader) {
         val result = readName().toTypeName
         val params = until(end)(readName().toTypeName)
         var sig = Signature(params, result)
-        if (sig == Signature.NotAMethod) sig = Signature.NotAMethod
-        SignedName(original, sig)
+        if (sig == Signature.NotAMethod) sig = Signature.NotAMethod // needed temporarily, as long as we read old tasty
+        original.withSig(sig).asInstanceOf[TermName]
       case _ =>
         simpleNameKindOfTag(tag)(readName())
     }

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

@@ -335,7 +335,7 @@ class TreePickler(pickler: TastyPickler) {
           writeByte(if (name.isTypeName) SELECTtpt else SELECT)
           val sig = tree.tpe.signature
           pickleName(
-            if (name.isTypeName || sig == Signature.NotAMethod) name
+            if (sig eq Signature.NotAMethod) name
             else SignedName(name.toTermName, sig))
           pickleTree(qual)
         case Apply(fun, args) =>

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

@@ -720,9 +720,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
       val cls = ctx.owner.asClass
       val assumedSelfType =
         if (cls.is(Module) && cls.owner.isClass)
-          TermRef(
-            cls.owner.thisType,
-            cls.name.sourceModuleName.withSig(Signature.NotAMethod).localizeIfPrivate(cls))
+          TermRef(cls.owner.thisType, cls.name.sourceModuleName.localizeIfPrivate(cls))
         else NoType
       cls.info = new TempClassInfo(cls.owner.thisType, cls, cls.unforcedDecls, assumedSelfType)
       val localDummy = symbolAtCurrent()

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -705,7 +705,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         val pre = readTypeRef()
         val sym = readDisambiguatedSymbolRef(_.info.isParameterless)
         if (isLocal(sym) || (pre eq NoPrefix)) pre select sym
-        else TermRef(pre, sym.name.asTermName.withSig(Signature.NotAMethod)) // !!! should become redundant
+        else TermRef(pre, sym.name.asTermName)
       case SUPERtpe =>
         val thistpe = readTypeRef()
         val supertpe = readTypeRef()

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

@@ -93,10 +93,10 @@ class ParamForwarding(thisTransformer: DenotTransformer) {
 
   def adaptRef[T <: RefTree](tree: T)(implicit ctx: Context): T = tree.tpe match {
     case tpe: TermRef
-    if tpe.prefix.ne(NoPrefix) && tpe.signature == Signature.NotAMethod && tpe.symbol.is(Method) =>
+    if tpe.prefix.ne(NoPrefix) && tpe.signature.eq(Signature.NotAMethod) && tpe.symbol.is(Method) =>
       // It could be a param forwarder; adapt the signature
       val newSig = tpe.prefix.memberInfo(tpe.symbol).signature
-      if (newSig == Signature.NotAMethod) tree
+      if (newSig.eq(Signature.NotAMethod)) tree
       else tree.withType(
         TermRef(tpe.prefix, tpe.name.withSig(newSig).localizeIfPrivate(tpe.symbol)))
           .asInstanceOf[T]

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

@@ -432,7 +432,7 @@ trait ImplicitRunInfo { self: RunInfo =>
               def addRef(companion: TermRef): Unit = {
                 val compSym = companion.symbol
                 if (compSym is Package)
-                  addRef(TermRef(companion, nme.PACKAGE.withSig(Signature.NotAMethod)))
+                  addRef(TermRef(companion, nme.PACKAGE))
                 else if (compSym.exists)
                   comps += companion.asSeenFrom(pre, compSym.owner).asInstanceOf[TermRef]
               }