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

@@ -652,25 +652,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

@@ -229,7 +229,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

@@ -1962,7 +1962,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
@@ -2077,11 +2077,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

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.signature, denot)
+      } yield TermRef.withSigAndDenot(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/Inferencing.scala

@@ -196,7 +196,7 @@ object Inferencing {
       case tp: TypeRef =>
         val companion = tp.classSymbol.companionModule
         if (companion.exists)
-          companion.valRef.asSeenFrom(tp.prefix, companion.symbol.owner)
+          companion.termRef.asSeenFrom(tp.prefix, companion.symbol.owner)
         else NoType
       case _ => NoType
     }

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

@@ -515,10 +515,10 @@ trait TypeAssigner {
     tree.withType(proto)
 
   def assignType(tree: untpd.ValDef, sym: Symbol)(implicit ctx: Context) =
-    tree.withType(if (sym.exists) assertExists(symbolicIfNeeded(sym).orElse(sym.valRef)) else NoType)
+    tree.withType(if (sym.exists) assertExists(symbolicIfNeeded(sym).orElse(sym.termRef)) else NoType)
 
   def assignType(tree: untpd.DefDef, sym: Symbol)(implicit ctx: Context) =
-    tree.withType(symbolicIfNeeded(sym).orElse(sym.termRefWithSig))
+    tree.withType(symbolicIfNeeded(sym).orElse(sym.termRef))
 
   def assignType(tree: untpd.TypeDef, sym: Symbol)(implicit ctx: Context) =
     tree.withType(symbolicIfNeeded(sym).orElse(sym.typeRef))
@@ -545,7 +545,7 @@ trait TypeAssigner {
     tree.withType(AnnotatedType(arg.tpe.widen, Annotation(annot)))
 
   def assignType(tree: untpd.PackageDef, pid: Tree)(implicit ctx: Context) =
-    tree.withType(pid.symbol.valRef)
+    tree.withType(pid.symbol.termRef)
 
   /** Ensure that `tree2`'s type is in the same universe as `tree1`. If that's the case, return
    *  `op` applied to both types.

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

@@ -1517,7 +1517,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           ctx
         }
       val stats1 = typedStats(tree.stats, pkg.moduleClass)(packageContext)
-      cpy.PackageDef(tree)(pid1.asInstanceOf[RefTree], stats1) withType pkg.valRef
+      cpy.PackageDef(tree)(pid1.asInstanceOf[RefTree], stats1) withType pkg.termRef
     } else errorTree(tree, i"package ${tree.pid.name} does not exist")
   }
 
@@ -1905,8 +1905,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 (alt =>
-        TermRef.withSigAndDenot(ref.prefix, ref.name, alt.info.signature, alt))
+      val alts = altDenots.map(TermRef.withSigAndDenot(ref.prefix, ref.name, _))
       resolveOverloaded(alts, pt) match {
         case alt :: Nil =>
           adapt(tree.withType(alt), pt)