Drop nonMemberTermRef

Make nonMemberTermRef redundant by marking local dummies
and import symbols as Fresh (i.e. they are non-members).

Author: odersky

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

@@ -243,7 +243,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val localDummy = ((NoSymbol: Symbol) /: body)(findLocalDummy.apply)
       .orElse(ctx.newLocalDummy(cls))
     val impl = untpd.Template(constr, parents, selfType, newTypeParams ++ body)
-      .withType(localDummy.nonMemberTermRef)
+      .withType(localDummy.termRef)
     ta.assignType(untpd.TypeDef(cls.name, impl), cls)
   }
 

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

@@ -1135,9 +1135,6 @@ object SymDenotations {
     override def termRefWithSig(implicit ctx: Context): TermRef =
       TermRef.withSigAndDenot(owner.thisType, name.asTermName, signature, this)
 
-    def nonMemberTermRef(implicit ctx: Context): TermRef =
-      TermRef(owner.thisType, symbol.asTerm)
-
     /** 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/Symbols.scala

@@ -249,8 +249,12 @@ trait Symbols { this: Context =>
     newSymbol(cls, nme.localDummyName(cls), Fresh, NoType)
 
   /** Create an import symbol pointing back to given qualifier `expr`. */
-  def newImportSymbol(owner: Symbol, expr: Tree, coord: Coord = NoCoord) =
-    newSymbol(owner, nme.IMPORT, EmptyFlags, ImportType(expr), coord = coord)
+  def newImportSymbol(owner: Symbol, expr: Tree, coord: Coord = NoCoord): TermSymbol =
+    newImportSymbol(owner, ImportType(expr), coord = coord)
+
+  /** Create an import symbol with given `info`. */
+  def newImportSymbol(owner: Symbol, info: Type, coord: Coord): TermSymbol =
+    newSymbol(owner, nme.IMPORT, Synthetic | Fresh, info, coord = coord)
 
   /** Create a class constructor symbol for given class `cls`. */
   def newConstructor(cls: ClassSymbol, flags: FlagSet, paramNames: List[TermName], paramTypes: List[Type], privateWithin: Symbol = NoSymbol, coord: Coord = NoCoord) =

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

@@ -753,7 +753,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
       })
       setPos(start,
         untpd.Template(constr, parents, self, lazyStats)
-          .withType(localDummy.nonMemberTermRef))
+          .withType(localDummy.termRef))
     }
 
     def skipToplevel()(implicit ctx: Context): Unit= {

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

@@ -324,8 +324,7 @@ class Namer { typer: Typer =>
           adjustIfModule(completer, tree),
           privateWithinClass(tree.mods), tree.namePos), tree)
       case tree: Import =>
-        recordSym(ctx.newSymbol(
-          ctx.owner, nme.IMPORT, Synthetic | Fresh, new Completer(tree), NoSymbol, tree.pos), tree)
+        recordSym(ctx.newImportSymbol(ctx.owner, new Completer(tree), tree.pos), tree)
       case _ =>
         NoSymbol
     }

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

@@ -523,12 +523,12 @@ trait TypeAssigner {
   def assignType(tree: untpd.TypeDef, sym: Symbol)(implicit ctx: Context) =
     tree.withType(symbolicIfNeeded(sym).orElse(sym.typeRef))
 
-  private def symbolicIfNeeded(sym: Symbol)(implicit ctx: Context) = {
+  private def symbolicIfNeeded(sym: Symbol)(implicit ctx: Context) = { // ??? can we drop this?
     val owner = sym.owner
     if (owner.isClass && owner.isCompleted && owner.asClass.givenSelfType.exists)
       // In that case a simple typeRef/termWithWithSig could return a member of
       // the self type, not the symbol itself. To avoid this, we make the reference
-      // symbolic. In general it seems to be faster to keep the non-symblic
+      // symbolic. In general it seems to be faster to keep the non-symbolic
       // reference, since there is less pressure on the uniqueness tables that way
       // and less work to update all the different references. That's why symbolic references
       // are only used if necessary.
@@ -539,7 +539,7 @@ trait TypeAssigner {
   def assertExists(tp: Type) = { assert(tp != NoType); tp }
 
   def assignType(tree: untpd.Import, sym: Symbol)(implicit ctx: Context) =
-    tree.withType(sym.nonMemberTermRef)
+    tree.withType(sym.termRef)
 
   def assignType(tree: untpd.Annotated, arg: Tree, annot: Tree)(implicit ctx: Context) =
     tree.withType(AnnotatedType(arg.tpe.widen, Annotation(annot)))

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

@@ -1410,7 +1410,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
       checkNoDoubleDefs(cls)
       val impl1 = cpy.Template(impl)(constr1, parents1, self1, body1)
-        .withType(dummy.nonMemberTermRef)
+        .withType(dummy.termRef)
       checkVariance(impl1)
       if (!cls.is(AbstractOrTrait) && !ctx.isAfterTyper)
         checkRealizableBounds(cls, cdef.namePos)