Eliminate termRefWithSig and valRef

Also, drop signature parameter in TermRef.withSigAndDenot

Author: odersky

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

@@ -702,8 +702,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           TypeRef(tree.tpe, sym.name.asTypeName)
         }
         else
-          TermRef.withSigAndDenot(tree.tpe, sym.name.asTermName,
-            sym.denot.asSeenFrom(tree.tpe))
+          TermRef(tree.tpe, sym.name.asTermName, sym.denot.asSeenFrom(tree.tpe))
       untpd.Select(tree, sym.name).withType(tp)
     }
 

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

@@ -140,7 +140,7 @@ object Annotations {
 
     def makeAlias(sym: TermSymbol)(implicit ctx: Context) =
       apply(defn.AliasAnnot, List(
-        ref(TermRef.withSigAndDenot(sym.owner.thisType, sym.name, sym))))
+        ref(TermRef(sym.owner.thisType, sym.name, sym))))
 
     def makeChild(delayedSym: Context => Symbol)(implicit ctx: Context): Annotation = {
       def makeChildLater(implicit ctx: Context) = {

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

@@ -1959,7 +1959,7 @@ object Types {
     override def isOverloaded(implicit ctx: Context) = denot.isOverloaded
 
     private def rewrap(sd: SingleDenotation)(implicit ctx: Context) =
-      TermRef.withSigAndDenot(prefix, name, sd)
+      TermRef(prefix, name, sd)
 
     def alternatives(implicit ctx: Context): List[TermRef] =
       denot.alternatives map rewrap
@@ -2063,23 +2063,12 @@ object Types {
      *  signature, if denotation is not yet completed.
      */
     def apply(prefix: Type, name: TermName, denot: Denotation)(implicit ctx: Context): TermRef = {
-      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically)
-        apply(prefix, denot.symbol.asTerm)
+      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically) apply(prefix, denot.symbol.asTerm)
       else denot match {
-        case denot: SymDenotation if denot.isCompleted =>
-          apply(prefix, name.withSig(denot.signature))
-        case _ =>
-          apply(prefix, name)
+        case denot: SingleDenotation => apply(prefix, name.withSig(denot.signature))
+        case _ => apply(prefix, name)
       }
     } withDenot denot
-
-    /** Create a term ref with given prefix, name, signature, and initial denotation */
-    def withSigAndDenot(prefix: Type, name: TermName, denot: Denotation)(implicit ctx: Context): TermRef = {
-      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically)
-        apply(prefix, denot.symbol.asTerm)
-      else
-        apply(prefix, name.withSig(denot.signature))
-    } withDenot denot
   }
 
   object TypeRef {

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

@@ -102,7 +102,7 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
       for {
         renamed <- reverseMapping.keys
         denot <- pre.member(reverseMapping(renamed)).altsWith(_ is Implicit)
-      } yield TermRef.withSigAndDenot(pre, renamed, denot)
+      } yield TermRef(pre, renamed, denot)
   }
 
   /** The root import symbol hidden by this symbol, or NoSymbol if no such symbol is hidden.

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

@@ -1904,7 +1904,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     def adaptOverloaded(ref: TermRef) = {
       val altDenots = ref.denot.alternatives
       typr.println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%, %")
-      val alts = altDenots.map(TermRef.withSigAndDenot(ref.prefix, ref.name, _))
+      val alts = altDenots.map(TermRef(ref.prefix, ref.name, _))
       resolveOverloaded(alts, pt) match {
         case alt :: Nil =>
           adapt(tree.withType(alt), pt)