Eliminate termRefWithSig and valRef

Also, drop signature parameter in TermRef.withSigAndDenot

Author: odersky

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

@@ -1057,7 +1057,7 @@ object desugar {
         } else if (arity == 1) ts.head
         else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts)
         else if (arity == 0) unitLiteral
-        else Apply(ref(tupleTypeRef.classSymbol.companionModule.valRef), ts)
+        else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
       case WhileDo(cond, body) =>
         // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
         val call = Apply(Ident(nme.WHILE_PREFIX), Nil).withPos(tree.pos)

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

@@ -703,7 +703,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         }
         else
           TermRef.withSigAndDenot(tree.tpe, sym.name.asTermName,
-            sym.signature, sym.denot.asSeenFrom(tree.tpe))
+            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.signature, sym))))
+        ref(TermRef.withSigAndDenot(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/Denotations.scala

@@ -653,25 +653,11 @@ object Denotations {
     def termRef(implicit ctx: Context): TermRef =
       TermRef(symbol.owner.thisType, symbol.name.asTermName, this)
 
-    /** The TermRef representing this term denotation at its original location
-     *  and at signature `NotAMethod`.
-     */
-    def valRef(implicit ctx: Context): TermRef =
-      TermRef.withSigAndDenot(symbol.owner.thisType, symbol.name.asTermName, Signature.NotAMethod, this)
-
-    /** The TermRef representing this term denotation at its original location
-     *  at the denotation's signature.
-     *  @note  Unlike `valRef` and `termRef`, this will force the completion of the
-     *         denotation via a call to `info`.
-     */
-    def termRefWithSig(implicit ctx: Context): TermRef =
-      TermRef.withSigAndDenot(symbol.owner.thisType, symbol.name.asTermName, signature, this)
-
     /** The NamedType representing this denotation at its original location.
-     *  Same as either `typeRef` or `termRefWithSig` depending whether this denotes a type or not.
+     *  Same as either `typeRef` or `termRef` depending whether this denotes a type or not.
      */
     def namedType(implicit ctx: Context): NamedType =
-      if (isType) typeRef else termRefWithSig
+      if (isType) typeRef else termRef
 
     // ------ Transformations -----------------------------------------
 

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

@@ -409,7 +409,7 @@ object Scopes {
       while (e ne null) {
         if (e.sym is Implicit) {
           val d = e.sym.denot
-          irefs += TermRef.withSigAndDenot(NoPrefix, d.name.asTermName, d.signature, d)
+          irefs += TermRef(NoPrefix, d.symbol.asTerm).withDenot(d)
         }
         e = e.prev
       }

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

@@ -1129,12 +1129,6 @@ object SymDenotations {
     override def termRef(implicit ctx: Context): TermRef =
       TermRef(owner.thisType, name.asTermName, this)
 
-    override def valRef(implicit ctx: Context): TermRef =
-      TermRef.withSigAndDenot(owner.thisType, name.asTermName, Signature.NotAMethod, this)
-
-    override def termRefWithSig(implicit ctx: Context): TermRef =
-      TermRef.withSigAndDenot(owner.thisType, name.asTermName, signature, this)
-
     /** The variance of this type parameter or type member as an Int, with
      *  +1 = Covariant, -1 = Contravariant, 0 = Nonvariant, or not a type parameter
      */

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

@@ -219,7 +219,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
   def makePackageObjPrefixExplicit(tpe: NamedType): Type = {
     def tryInsert(pkgClass: SymDenotation): Type = pkgClass match {
       case pkgCls: PackageClassDenotation if !(tpe.symbol.maybeOwner is Package) =>
-        tpe.derivedSelect(pkgCls.packageObj.valRef)
+        tpe.derivedSelect(pkgCls.packageObj.termRef)
       case _ =>
         tpe
     }

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

@@ -1957,7 +1957,7 @@ object Types {
     override def isOverloaded(implicit ctx: Context) = denot.isOverloaded
 
     private def rewrap(sd: SingleDenotation)(implicit ctx: Context) =
-      TermRef.withSigAndDenot(prefix, name, sd.signature, sd)
+      TermRef.withSigAndDenot(prefix, name, sd)
 
     def alternatives(implicit ctx: Context): List[TermRef] =
       denot.alternatives map rewrap
@@ -2072,11 +2072,11 @@ object Types {
     } withDenot denot
 
     /** 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 = {
+    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(sig))
+        apply(prefix, name.withSig(denot.signature))
     } withDenot denot
   }
 

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

@@ -29,7 +29,7 @@ object EtaExpansion {
       val liftedType = fullyDefinedType(expr.tpe.widen, "lifted expression", expr.pos)
       val sym = ctx.newSymbol(ctx.owner, name, EmptyFlags, liftedType, coord = positionCoord(expr.pos))
       defs += ValDef(sym, expr)
-      ref(sym.valRef)
+      ref(sym.termRef)
     }
 
   /** Lift out common part of lhs tree taking part in an operator assignment such as

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

@@ -435,7 +435,7 @@ trait ImplicitRunInfo { self: RunInfo =>
               def addParentScope(parent: Type): Unit =
                 iscopeRefs(tp.baseType(parent.typeSymbol)) foreach addRef
               val companion = cls.companionModule
-              if (companion.exists) addRef(companion.valRef)
+              if (companion.exists) addRef(companion.termRef)
               cls.classParents foreach addParentScope
             }
             tp.classSymbols(liftingCtx) foreach addClassScope