Go back to withSym creation methods for NamedTypes

It allows us to drop the additional name field in most cases and
the methods become easier to discover.

Author: odersky

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

@@ -382,7 +382,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val targs = tp.argTypes
     val tycon = tp.typeConstructor
     New(tycon)
-      .select(TermRef(tycon, constr, constr.name))
+      .select(TermRef.withSym(tycon, constr))
       .appliedToTypes(targs)
       .appliedToArgs(args)
   }
@@ -916,9 +916,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         alternatives.head
       }
       else denot.asSingleDenotation.termRef
-    val selectedSym = selected.termSymbol.asTerm
     val fun = receiver
-      .select(TermRef(receiver.tpe, selectedSym, selectedSym.name))
+      .select(TermRef.withSym(receiver.tpe, selected.termSymbol.asTerm))
       .appliedToTypes(targs)
 
     def adaptLastArg(lastParam: Tree, expectedType: Type) = {

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

@@ -1395,7 +1395,7 @@ object SymDenotations {
     private def computeThisType(implicit ctx: Context): Type = {
       val cls = symbol.asType
       val pre = if (this is Package) NoPrefix else owner.thisType
-      ThisType.raw(TypeRef(pre, cls, cls.name))
+      ThisType.raw(TypeRef.withSym(pre, cls))
     }
 
     private[this] var myTypeRef: TypeRef = null

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

@@ -154,7 +154,7 @@ trait Symbols { this: Context =>
         infoFn(module, modcls), privateWithin)
     val mdenot = SymDenotation(
         module, owner, name, modFlags | ModuleCreationFlags,
-        if (cdenot.isCompleted) TypeRef(owner.thisType, modcls, modclsName)
+        if (cdenot.isCompleted) TypeRef.withSym(owner.thisType, modcls, modclsName)
         else new ModuleCompleter(modcls))
     module.denot = mdenot
     modcls.denot = cdenot
@@ -179,7 +179,7 @@ trait Symbols { this: Context =>
     newModuleSymbol(
         owner, name, modFlags, clsFlags,
         (module, modcls) => ClassInfo(
-          owner.thisType, modcls, parents, decls, TermRef(owner.thisType, module, name)),
+          owner.thisType, modcls, parents, decls, TermRef.withSym(owner.thisType, module, name)),
         privateWithin, coord, assocFile)
 
   val companionMethodFlags = Flags.Synthetic | Flags.Private | Flags.Method
@@ -287,7 +287,7 @@ trait Symbols { this: Context =>
     for (name <- names) {
       val tparam = newNakedSymbol[TypeName](NoCoord)
       tparamBuf += tparam
-      trefBuf += TypeRef(owner.thisType, tparam, name)
+      trefBuf += TypeRef.withSym(owner.thisType, tparam, name)
     }
     val tparams = tparamBuf.toList
     val bounds = boundsFn(trefBuf.toList)

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

@@ -707,10 +707,7 @@ 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 =>
-          val mbr = d.symbol.asTerm
-          TermRef(this, mbr, mbr.name)
-        }
+        .toList.map(d => TermRef.withSym(this, d.symbol.asTerm))
     }
 
     /** The set of member classes of this type */
@@ -1136,7 +1133,7 @@ object Types {
 
     /** The type <this . name> with either `sym` or its signed name as designator, reduced if possible */
     def select(sym: Symbol)(implicit ctx: Context): Type =
-      NamedType(this, sym, sym.name).reduceProjection
+      NamedType.withSym(this, sym).reduceProjection
 
 // ----- Access to parts --------------------------------------------
 
@@ -2034,9 +2031,9 @@ object Types {
     def apply(prefix: Type, designator: Name, denot: Denotation)(implicit ctx: Context) =
       if (designator.isTermName) TermRef(prefix, designator.asTermName, denot)
       else TypeRef(prefix, designator.asTypeName, denot)
-    def apply(prefix: Type, sym: Symbol, name: Name)(implicit ctx: Context): NamedType =
-      if (sym.isType) TypeRef.apply(prefix, sym.asType, name.asTypeName)
-      else TermRef.apply(prefix, sym.asTerm, name.asTermName)
+    def withSym(prefix: Type, sym: Symbol)(implicit ctx: Context): NamedType =
+      if (sym.isType) TypeRef.withSym(prefix, sym.asType)
+      else TermRef.withSym(prefix, sym.asTerm)
   }
 
   object TermRef {
@@ -2048,15 +2045,6 @@ object Types {
     def apply(prefix: Type, designator: TermDesignator)(implicit ctx: Context): TermRef =
       ctx.uniqueNamedTypes.enterIfNew(prefix, designator, isTerm = true).asInstanceOf[TermRef]
 
-    /** Create a term ref referring to given symbol with given name.
-     *  This is similar to TermRef(Type, Symbol), except:
-     *  (1) the symbol might not yet have a denotation, so the name needs to be given explicitly.
-     *  (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 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.
@@ -2068,6 +2056,18 @@ object Types {
         case _ => apply(prefix, name)
       }
     } withDenot denot
+
+    /** Create a term ref referring to given symbol with given name.
+     *  This is similar to TermRef(Type, Symbol), except:
+     *  (1) the symbol might not yet have a denotation, so the name needs to be given explicitly.
+     *  (2) the designator of the TermRef is either the symbol or its name & unforced signature.
+     */
+    def withSym(prefix: Type, sym: TermSymbol, name: TermName)(implicit ctx: Context): TermRef =
+      if ((prefix eq NoPrefix) || sym.isReferencedSymbolically) apply(prefix, sym)
+      else apply(prefix, name.withSig(sym.signature)).withSym(sym)
+
+    def withSym(prefix: Type, sym: TermSymbol)(implicit ctx: Context): TermRef =
+      withSym(prefix, sym, sym.name)
   }
 
   object TypeRef {
@@ -2076,20 +2076,23 @@ object Types {
     def apply(prefix: Type, desig: TypeDesignator)(implicit ctx: Context): TypeRef =
       ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = false).asInstanceOf[TypeRef]
 
+    /** Create a type ref with given name and initial denotation */
+    def apply(prefix: Type, name: TypeName, denot: Denotation)(implicit ctx: Context): TypeRef = {
+      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically) apply(prefix, denot.symbol.asType)
+      else apply(prefix, name)
+    } withDenot denot
+
     /** Create a type ref referring to either a given symbol or its name.
      *  This is similar to TypeRef(prefix, sym), except:
      *  (1) the symbol might not yet have a denotation, so the name needs to be given explicitly.
      *  (2) the designator of the TypeRef is either the symbol or its name
      */
-    def apply(prefix: Type, sym: TypeSymbol, name: TypeName)(implicit ctx: Context): TypeRef =
+    def withSym(prefix: Type, sym: TypeSymbol, name: TypeName)(implicit ctx: Context): TypeRef =
       if ((prefix eq NoPrefix) || sym.isReferencedSymbolically) apply(prefix, sym)
       else apply(prefix, name).withSym(sym)
 
-    /** Create a type ref with given name and initial denotation */
-    def apply(prefix: Type, name: TypeName, denot: Denotation)(implicit ctx: Context): TypeRef = {
-      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically) apply(prefix, denot.symbol.asType)
-      else apply(prefix, name)
-    } withDenot denot
+    def withSym(prefix: Type, sym: TypeSymbol)(implicit ctx: Context): TypeRef =
+      withSym(prefix, sym, sym.name)
   }
 
   // --- Other SingletonTypes: ThisType/SuperType/ConstantType ---------------------------
@@ -3374,7 +3377,7 @@ object Types {
       appliedRefCache
     }
 
-    def symbolicTypeRef(implicit ctx: Context): TypeRef = TypeRef(prefix, cls, cls.name)
+    def symbolicTypeRef(implicit ctx: Context): TypeRef = TypeRef.withSym(prefix, cls)
 
     // cached because baseType needs parents
     private[this] var parentsCache: List[Type] = null

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

@@ -330,7 +330,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
     private def readSymNameRef()(implicit ctx: Context): Type = {
       val sym = readSymRef()
       val prefix = readType()
-      val res = NamedType(prefix, sym, sym.name)
+      val res = NamedType.withSym(prefix, sym)
       prefix match {
         case prefix: ThisType if prefix.cls eq sym.owner => res.withDenot(sym.denot)
           // without this precaution we get an infinite cycle when unpickling pos/extmethods.scala

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

@@ -384,8 +384,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           val companion = cls.companionModule
           if (companion.isTerm) {
             val prefix = receiver.tpe.baseType(cls).normalizedPrefix
-            if (prefix.exists)
-              selectGetter(ref(TermRef(prefix, companion.asTerm, companion.name.asTermName)))
+            if (prefix.exists) selectGetter(ref(TermRef.withSym(prefix, companion.asTerm)))
             else EmptyTree
           }
           else EmptyTree

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

@@ -1008,7 +1008,7 @@ class TermRefSet(implicit ctx: Context) extends mutable.Traversable[TermRef] {
   override def foreach[U](f: TermRef => U): Unit =
     for (sym <- elems.keysIterator)
       for (pre <- elems(sym))
-        f(TermRef(pre, sym, sym.name))
+        f(TermRef.withSym(pre, sym))
 }
 
 @sharable object EmptyTermRefSet extends TermRefSet()(NoContext)