Drop OverloadedSymbol/Denotation

It caused errors even in the old scheme, because we now had another
symbol that "existed" yet did not have an owner.

Also, change creation methods for NamedTypes to accommodate
NoSymbol as a symbol of an overloaded denotation.

Author: odersky

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

@@ -1857,15 +1857,13 @@ object SymDenotations {
     override def owner: Symbol = throw new AssertionError("NoDenotation.owner")
     override def computeAsSeenFrom(pre: Type)(implicit ctx: Context): SingleDenotation = this
     override def mapInfo(f: Type => Type)(implicit ctx: Context): SingleDenotation = this
+    sym.denot = this
     validFor = Period.allInRun(NoRunId)
   }
 
-  @sharable val NoDenotation =
+  @sharable val NoDenotation: NoDenotation =
     new NoDenotation(NoSymbol, "<none>".toTermName, exists = false)
 
-  @sharable val OverloadedDenotation =
-    new NoDenotation(OverloadedSymbol, "<overloaded>".toTermName, exists = true)
-
   // ---- Completion --------------------------------------------------------
 
   /** Instances of LazyType are carried by uncompleted symbols.

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

@@ -650,19 +650,12 @@ object Symbols {
     denot = underlying.denot
   }
 
-  class NonExistingSymbol extends Symbol(NoCoord, 0) {
+  @sharable val NoSymbol = new Symbol(NoCoord, 0) {
     override def associatedFile(implicit ctx: Context): AbstractFile = NoSource.file
     override def recomputeDenot(lastd: SymDenotation)(implicit ctx: Context): SymDenotation = NoDenotation
   }
 
-  @sharable object NoSymbol extends NonExistingSymbol {
-    denot = NoDenotation
-  }
-
-  @sharable object OverloadedSymbol extends NonExistingSymbol {
-    denot = OverloadedDenotation
-    type ThisName = TermName
-  }
+  NoDenotation // force it in order to set `denot` field of NoSymbol
 
   implicit class Copier[N <: Name](sym: Symbol { type ThisName = N })(implicit ctx: Context) {
     /** Copy a symbol, overriding selective fields */

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

@@ -2097,7 +2097,7 @@ object Types {
     def applyOLD(prefix: Type, designator: TermDesignator)(implicit ctx: Context): TermRef =
       ctx.uniqueNamedTypes.enterIfNew(prefix, designator, isTerm = true).asInstanceOf[TermRef]
 
-    def apply(prefix: Type, designator: TermSymbol)(implicit ctx: Context): TermRef =
+    def apply(prefix: Type, designator: Symbol)(implicit ctx: Context): TermRef =
       ctx.uniqueNamedTypes.enterIfNew(prefix, designator, isTerm = true).asInstanceOf[TermRef]
 
     /** Create term ref to given initial denotation, taking the signature
@@ -2115,7 +2115,7 @@ object Types {
     } withDenot denot
 
     def withDenot(prefix: Type, denot: Denotation)(implicit ctx: Context): TermRef =
-      apply(prefix, denot.symbol.asTerm).withDenot(denot)
+      apply(prefix, denot.symbol).withDenot(denot)
 
     /** Create a term ref referring to given symbol with given name.
      *  This is similar to TermRef(Type, Symbol), except:
@@ -2137,7 +2137,7 @@ object Types {
       ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = false).asInstanceOf[TypeRef]
 
     /** Create type ref with given prefix and name */
-    def apply(prefix: Type, desig: TypeSymbol)(implicit ctx: Context): TypeRef =
+    def apply(prefix: Type, desig: Symbol)(implicit ctx: Context): TypeRef =
       ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = false).asInstanceOf[TypeRef]
 
     /** Create a type ref with given name and initial denotation */
@@ -2148,7 +2148,7 @@ object Types {
     } withDenot denot
 
     def withDenot(prefix: Type, denot: Denotation)(implicit ctx: Context): TypeRef =
-      apply(prefix, denot.symbol.asType).withDenot(denot)
+      apply(prefix, denot.symbol).withDenot(denot)
 
     /** Create a type ref referring to either a given symbol or its name.
      *  This is similar to TypeRef(prefix, sym), except: