Drop NamedType.withSym

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.withSym(tycon, constr))
+      .select(TermRef(tycon, constr))
       .appliedToTypes(targs)
       .appliedToArgs(args)
   }
@@ -917,7 +917,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
       else denot.asSingleDenotation.termRef
     val fun = receiver
-      .select(TermRef.withSym(receiver.tpe, selected.termSymbol.asTerm))
+      .select(TermRef(receiver.tpe, selected.termSymbol.asTerm))
       .appliedToTypes(targs)
 
     def adaptLastArg(lastParam: Tree, expectedType: Type) = {

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

@@ -1401,7 +1401,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.withSym(pre, cls))
+      ThisType.raw(TypeRef(pre, cls))
     }
 
     private[this] var myTypeRef: TypeRef = null

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

@@ -709,7 +709,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 => TermRef.withSym(this, d.symbol.asTerm))
+        .toList.map(d => TermRef(this, d.symbol.asTerm))
     }
 
     /** The set of member classes of this type */
@@ -1135,7 +1135,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.withSym(this, sym).reduceProjection
+      NamedType(this, sym).reduceProjection
 
     def select(name: TermName)(implicit ctx: Context): TermRef =
       TermRef(this, name, member(name))
@@ -2010,43 +2010,32 @@ object Types {
     def apply(prefix: Type, designator: Name, denot: Denotation)(implicit ctx: Context) =
       if (designator.isTermName) TermRef.apply(prefix, designator.asTermName, denot)
       else TypeRef.apply(prefix, designator.asTypeName, denot)
-    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 {
 
-    /** Create term ref with given name, without specifying a signature.
-     *  Its meaning is the (potentially multi-) denotation of the member(s)
-     *  of prefix with given name.
-     */
+    /** Create a term ref with given designator */
     def apply(prefix: Type, desig: Designator)(implicit ctx: Context): TermRef =
       ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = true).asInstanceOf[TermRef]
 
-    /** 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.
+    /** Create a term ref with given initial denotation. The name of the reference is taken
+     *  from the denotation's symbol if the latter exists, or else it is the given name.
      */
     def apply(prefix: Type, name: TermName, denot: Denotation)(implicit ctx: Context): TermRef =
       apply(prefix, if (denot.symbol.exists) denot.symbol.asTerm else name).withDenot(denot)
-
-    def withSym(prefix: Type, sym: TermSymbol)(implicit ctx: Context): TermRef =
-      apply(prefix, sym) // ###
   }
 
   object TypeRef {
 
-    /** Create type ref with given prefix and name */
+    /** Create a type ref with given prefix and name */
     def apply(prefix: Type, desig: Designator)(implicit ctx: Context): TypeRef =
       ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = false).asInstanceOf[TypeRef]
 
-    /** Create a type ref with given name and initial denotation */
+    /** Create a type ref with given initial denotation. The name of the reference is taken
+     *  from the denotation's symbol if the latter exists, or else it is the given name.
+     */
     def apply(prefix: Type, name: TypeName, denot: Denotation)(implicit ctx: Context): TypeRef =
       apply(prefix, if (denot.symbol.exists) denot.symbol.asType else name).withDenot(denot)
-
-    def withSym(prefix: Type, sym: TypeSymbol)(implicit ctx: Context): TypeRef =
-      apply(prefix, sym) // ###
   }
 
   // --- Other SingletonTypes: ThisType/SuperType/ConstantType ---------------------------

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

@@ -352,7 +352,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.withSym(prefix, sym)
+      val res = NamedType(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

@@ -385,7 +385,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.withSym(prefix, companion.asTerm)))
+            if (prefix.exists) selectGetter(ref(TermRef(prefix, companion.asTerm)))
             else EmptyTree
           }
           else EmptyTree

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

@@ -1134,7 +1134,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.withSym(pre, sym))
+        f(TermRef(pre, sym))
 }
 
 @sharable object EmptyTermRefSet extends TermRefSet()(NoContext)