Eliminate TermRef.withSig

To do this, we needed a more robust version of Symbol#signature.

Author: odersky

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

@@ -6,7 +6,7 @@ import dotty.tools.dotc.transform.{ExplicitOuter, Erasure}
 import dotty.tools.dotc.typer.ProtoTypes.FunProtoTyped
 import transform.SymUtils._
 import core._
-import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._
+import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Symbols._
 import Denotations._, Decorators._, DenotTransformers._
 import collection.mutable
@@ -382,7 +382,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val targs = tp.argTypes
     val tycon = tp.typeConstructor
     New(tycon)
-      .select(TermRef.withSig(tycon, constr))
+      .select(TermRef(tycon, constr, constr.name))
       .appliedToTypes(targs)
       .appliedToArgs(args)
   }
@@ -704,14 +704,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         else
           TermRef.withSigAndDenot(tree.tpe, sym.name.asTermName,
             sym.signature, sym.denot.asSeenFrom(tree.tpe))
-      untpd.Select(tree, sym.name)
-        .withType(tp)
+      untpd.Select(tree, sym.name).withType(tp)
     }
 
     /** A select node with the given selector name and signature and a computed type */
     def selectWithSig(name: Name, sig: Signature)(implicit ctx: Context): Tree =
       untpd.SelectWithSig(tree, name, sig)
-        .withType(TermRef.withSig(tree.tpe, name.asTermName, sig))
+        .withType(TermRef(tree.tpe, name.asTermName.withSig(sig)))
 
     /** A select node with selector name and signature taken from `sym`.
      *  Note: Use this method instead of select(sym) if the referenced symbol
@@ -918,8 +917,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         alternatives.head
       }
       else denot.asSingleDenotation.termRef
+    val selectedSym = selected.termSymbol.asTerm
     val fun = receiver
-      .select(TermRef.withSig(receiver.tpe, selected.termSymbol.asTerm))
+      .select(TermRef(receiver.tpe, selectedSym, selectedSym.name))
       .appliedToTypes(targs)
 
     def adaptLastArg(lastParam: Tree, expectedType: Type) = {

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

@@ -455,10 +455,12 @@ object Symbols {
         )
     }
 
-    /** The symbol's signature if it is completed, NotAMethod otherwise. */
-    final def unforcedSignature(implicit ctx: Context) =
-      if (lastDenot != null && lastDenot.isCompleted) lastDenot.signature
-      else Signature.NotAMethod
+    /** The symbol's signature if it is completed or a method, NotAMethod otherwise. */
+    final def signature(implicit ctx: Context) =
+      if (lastDenot != null && (lastDenot.isCompleted || lastDenot.is(Method)))
+        denot.signature
+      else
+        Signature.NotAMethod
 
     /** Special cased here, because it may be used on naked symbols in substituters */
     final def isStatic(implicit ctx: Context): Boolean =

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

@@ -707,7 +707,10 @@ object Types {
     final def implicitMembers(implicit ctx: Context): List[TermRef] = track("implicitMembers") {
       memberDenots(implicitFilter,
           (name, buf) => buf ++= member(name).altsWith(_ is Implicit))
-        .toList.map(d => TermRef.withSig(this, d.symbol.asTerm))
+        .toList.map { d =>
+          val mbr = d.symbol.asTerm
+          TermRef(this, mbr, mbr.name)
+        }
     }
 
     /** The set of member classes of this type */
@@ -1729,7 +1732,7 @@ object Types {
     }
 
     private def withSig(sig: Signature)(implicit ctx: Context): NamedType =
-      TermRef.withSig(prefix, name.asTermName, sig)
+      TermRef(prefix, name.asTermName.withSig(sig))
 
     protected def loadDenot(implicit ctx: Context): Denotation = {
       val d = asMemberOf(prefix, allowPrivate = true)
@@ -1985,7 +1988,7 @@ object Types {
         val candidate =
           if (newSig ne curSig) {
             core.println(i"sig change at ${ctx.phase} for $this, pre = $prefix, sig: $curSig --> $newSig")
-            TermRef.withSig(prefix, name, newSig)
+            TermRef(prefix, name.withSig(newSig))
           }
           else TermRef(prefix, designator)
         fixDenot(candidate, prefix)
@@ -2050,41 +2053,30 @@ object Types {
      *  (2) the designator of the TermRef is either the symbol or its name & unforced signature.
      */
     def apply(prefix: Type, sym: TermSymbol, name: TermName)(implicit ctx: Context): TermRef =
-      if ((prefix eq NoPrefix) || sym.isReferencedSymbolically)
-        apply(prefix, sym)
-      else
-        withSig(prefix, name.asTermName, sym.unforcedSignature).withSym(sym)
+      if ((prefix eq NoPrefix) || sym.isReferencedSymbolically) apply(prefix, sym)
+      else apply(prefix, name.withSig(sym.signature)).withSym(sym)
 
     /** Create term ref to given initial denotation, taking the signature
      *  from the denotation if it is completed, or creating a term ref without
      *  signature, if denotation is not yet completed.
      */
-    def apply(prefix: Type, designator: TermName, denot: Denotation)(implicit ctx: Context): TermRef = {
+    def apply(prefix: Type, name: TermName, denot: Denotation)(implicit ctx: Context): TermRef = {
       if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically)
         apply(prefix, denot.symbol.asTerm)
       else denot match {
-        case denot: SymDenotation if denot.isCompleted => withSig(prefix, designator, denot.signature)
-        case _ => apply(prefix, designator)
+        case denot: SymDenotation if denot.isCompleted =>
+          apply(prefix, name.withSig(denot.signature))
+        case _ =>
+          apply(prefix, name)
       }
     } withDenot denot
 
-    /** Create a term ref to given symbol, taking the signature from the symbol
-     *  (which must be completed).
-     */
-    def withSig(prefix: Type, sym: TermSymbol)(implicit ctx: Context): TermRef =
-      if ((prefix eq NoPrefix) || sym.isReferencedSymbolically) apply(prefix, sym)
-      else withSig(prefix, sym.name, sym.signature).withSym(sym)
-
-    /** Create a term ref with given prefix, name and signature */
-    def withSig(prefix: Type, name: TermName, sig: Signature)(implicit ctx: Context): TermRef =
-      apply(prefix, name.withSig(sig))
-
     /** Create a term ref with given prefix, name, signature, and initial denotation */
     def withSigAndDenot(prefix: Type, name: TermName, sig: Signature, denot: Denotation)(implicit ctx: Context): TermRef = {
       if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically)
         apply(prefix, denot.symbol.asTerm)
       else
-        withSig(prefix, name, sig)
+        apply(prefix, name.withSig(sig))
     } withDenot denot
   }
 

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

@@ -710,7 +710,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
       val cls = ctx.owner.asClass
       val assumedSelfType =
         if (cls.is(Module) && cls.owner.isClass)
-          TermRef.withSig(cls.owner.thisType, cls.name.sourceModuleName, Signature.NotAMethod)
+          TermRef(cls.owner.thisType, cls.name.sourceModuleName.withSig(Signature.NotAMethod))
         else NoType
       cls.info = new TempClassInfo(cls.owner.thisType, cls, cls.unforcedDecls, assumedSelfType)
       val localDummy = symbolAtCurrent()
@@ -871,7 +871,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
           untpd.Ident(readName().toTypeName).withType(readType())
         case SELECT =>
           def readRest(name: Name, sig: Signature) =
-            completeSelect(name, TermRef.withSig(_, name.asTermName, sig))
+            completeSelect(name, TermRef(_, name.asTermName.withSig(sig)))
           readName() match {
             case SignedName(name, sig) => readRest(name, sig)
             case name => readRest(name, Signature.NotAMethod)

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

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

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

@@ -4,7 +4,7 @@ package transform
 import core._
 import ast.Trees._
 import Contexts._, Types._, Symbols._, Flags._, TypeUtils._, DenotTransformers._, StdNames._
-import Decorators._
+import Decorators._, NameOps._
 import config.Printers.typr
 
 /** For all parameter accessors
@@ -96,7 +96,7 @@ class ParamForwarding(thisTransformer: DenotTransformer) {
       // It could be a param forwarder; adapt the signature
       val newSig = tpe.prefix.memberInfo(tpe.symbol).signature
       if (newSig == Signature.NotAMethod) tree
-      else tree.withType(TermRef.withSig(tpe.prefix, tpe.name, newSig)).asInstanceOf[T]
+      else tree.withType(TermRef(tpe.prefix, tpe.name.withSig(newSig))).asInstanceOf[T]
     case _ =>
       tree
   }

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

@@ -86,7 +86,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
   private def fixSignature[T <: Tree](tree: T)(implicit ctx: Context): T = tree.tpe match {
     case tpe: TermRef if tpe.signature.isUnderDefined =>
       typr.println(i"fixing $tree with type ${tree.tpe.widen.toString} with sig ${tpe.signature} to ${tpe.widen.signature}")
-      tree.withType(TermRef.withSig(tpe.prefix, tpe.name, tpe.widen.signature)).asInstanceOf[T]
+      tree.withType(TermRef(tpe.prefix, tpe.name.withSig(tpe.widen.signature))).asInstanceOf[T]
     case _ => tree
   }
 

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

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