Merge pull request #3087 from dotty-staging/change-termref

Generalize RefTypes

Author: odersky

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -431,11 +431,11 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     var found = desugared.get(i.tpe)
     if (found == null) {
       i.tpe match {
-        case TermRef(prefix: TermRef, name) =>
+        case TermRef(prefix: TermRef, _) =>
           found = tpd.ref(prefix).select(i.symbol)
-        case TermRef(prefix: ThisType, name) =>
+        case TermRef(prefix: ThisType, _) =>
           found = tpd.This(prefix.cls).select(i.symbol)
-        case TermRef(NoPrefix, name) =>
+        case TermRef(NoPrefix, _) =>
           if (i.symbol is Flags.Method) found = This(i.symbol.topLevelClass).select(i.symbol) // workaround #342 todo: remove after fixed
         case _ =>
       }

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/Trees.scala

@@ -86,7 +86,10 @@ object Trees {
      *  where we overwrite with a simplified version of the type itself.
      */
     private[dotc] def overwriteType(tpe: T) = {
-      if (this.isInstanceOf[Template[_]]) assert(tpe.isInstanceOf[WithFixedSym], s"$this <--- $tpe")
+      if (this.isInstanceOf[Template[_]])
+        tpe match {
+          case tpe: TermRef => assert(tpe.hasFixedSym , s"$this <--- $tpe")
+        }
       myTpe = tpe
     }
 

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

@@ -6,7 +6,7 @@ import dotty.tools.dotc.transform.{ExplicitOuter, Erasure}
 import dotty.tools.dotc.typer.ProtoTypes.FunProtoTyped
 import transform.SymUtils._
 import core._
-import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._
+import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Symbols._
 import Denotations._, Decorators._, DenotTransformers._
 import collection.mutable
@@ -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)
   }
 
@@ -382,7 +382,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val targs = tp.argTypes
     val tycon = tp.typeConstructor
     New(tycon)
-      .select(TermRef.withSig(tycon, constr))
+      .select(TermRef.withSym(tycon, constr))
       .appliedToTypes(targs)
       .appliedToArgs(args)
   }
@@ -702,16 +702,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           TypeRef(tree.tpe, sym.name.asTypeName)
         }
         else
-          TermRef.withSigAndDenot(tree.tpe, sym.name.asTermName,
-            sym.signature, sym.denot.asSeenFrom(tree.tpe))
-      untpd.Select(tree, sym.name)
-        .withType(tp)
+          TermRef(tree.tpe, sym.name.asTermName, sym.denot.asSeenFrom(tree.tpe))
+      untpd.Select(tree, sym.name).withType(tp)
     }
 
     /** A select node with the given selector name and signature and a computed type */
     def selectWithSig(name: Name, sig: Signature)(implicit ctx: Context): Tree =
       untpd.SelectWithSig(tree, name, sig)
-        .withType(TermRef.withSig(tree.tpe, name.asTermName, sig))
+        .withType(TermRef(tree.tpe, name.asTermName.withSig(sig)))
 
     /** A select node with selector name and signature taken from `sym`.
      *  Note: Use this method instead of select(sym) if the referenced symbol
@@ -919,7 +917,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
       else denot.asSingleDenotation.termRef
     val fun = receiver
-      .select(TermRef.withSig(receiver.tpe, selected.termSymbol.asTerm))
+      .select(TermRef.withSym(receiver.tpe, selected.termSymbol.asTerm))
       .appliedToTypes(targs)
 
     def adaptLastArg(lastParam: Tree, expectedType: Type) = {

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(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/Contexts.scala

@@ -614,13 +614,9 @@ object Contexts {
     /** A table for hash consing unique named types */
     private[core] val uniqueNamedTypes = new NamedTypeUniques
 
-    /** A table for hash consing unique symbolic named types */
-    private[core] val uniqueWithFixedSyms = new WithFixedSymUniques
-
     private def uniqueSets = Map(
         "uniques" -> uniques,
         "uniqueAppliedTypes" -> uniqueAppliedTypes,
-        "uniqueWithFixedSyms" -> uniqueWithFixedSyms,
         "uniqueNamedTypes" -> uniqueNamedTypes)
 
     /** A map that associates label and size of all uniques sets */

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

@@ -33,11 +33,11 @@ import Decorators.SymbolIteratorDecorator
  *
  *  Lines ending in a horizontal line mean subtying (right is a subtype of left).
  *
- *  NamedType------TermRefWithSignature
- *    |                    |                     Symbol---------ClassSymbol
- *    |                    |                       |                |
- *    | denot              | denot                 | denot          | denot
- *    v                    v                       v                v
+ *  NamedType
+ *    |                                          Symbol---------ClassSymbol
+ *    |                                            |                |
+ *    | denot                                      | denot          | denot
+ *    v                                            v                v
  *  Denotation-+-----SingleDenotation-+------SymDenotation-+----ClassDenotation
  *             |                      |
  *             +-----MultiDenotation  |
@@ -51,8 +51,6 @@ import Decorators.SymbolIteratorDecorator
  *                              prefix: Type
  *                              name: Name
  *                           It has two subtypes: TermRef and TypeRef
- *  TermRefWithSignature     A TermRef that has in addition a signature to select an overloaded variant, with new field
- *                              sig: Signature
  *  Symbol                   A label for a definition or declaration in one compiler run
  *  ClassSymbol              A symbol representing a class
  *  Denotation               The meaning of a named type or symbol during a period
@@ -655,25 +653,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/Designators.scala

@@ -0,0 +1,30 @@
+package dotty.tools
+package dotc
+package core
+
+import Names._
+import Contexts.Context
+
+/** Defines a common superclass of Name and Symbol and its Term/Type variants
+ *  Designators are used in reference type to identity what is referred to.
+ */
+object Designators {
+
+  abstract class Designator extends util.DotClass {
+
+    type ThisName <: Name
+
+    /** Classifiers and casts, to be overridden in implemetations */
+    def isName: Boolean = false
+    def isSymbol: Boolean = false
+
+    def isTerm(implicit ctx: Context) = false
+    def isType(implicit ctx: Context) = false
+
+    def asTerm(implicit ctx: Context): TermDesignator = unsupported("asTerm")
+    def asType(implicit ctx: Context): TypeDesignator = unsupported("asType")
+  }
+
+  type TermDesignator = Designator { type ThisName = TermName }
+  type TypeDesignator = Designator { type ThisName = TypeName }
+}

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

@@ -359,8 +359,8 @@ object Flags {
 
   // Flags following this one are not pickled
 
-  /** Symbol always defines a fresh named type */
-  final val Fresh = commonFlag(45, "<fresh>")
+  /** Symbol is not a member of its owner */
+  final val NonMember = commonFlag(45, "<non-member>")
 
   /** Denotation is in train of being loaded and completed, used to catch cyclic dependencies */
   final val Touched = commonFlag(48, "<touched>")
@@ -446,7 +446,7 @@ object Flags {
     Module | Package | Deferred | MethodOrHKCommon | Param | ParamAccessor.toCommonFlags |
     Scala2ExistentialCommon | Mutable.toCommonFlags | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessor.toCommonFlags |
-    Fresh | Erroneous | ImplicitCommon | Permanent | Synthetic |
+    NonMember | Erroneous | ImplicitCommon | Permanent | Synthetic |
     SuperAccessorOrScala2x | Inline
 
   /** Flags guaranteed to be set upon symbol creation, or, if symbol is a top-level

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

@@ -305,5 +305,7 @@ object NameOps {
       case raw.BANG  => UNARY_!
       case _ => name
     }
+
+    def withSig(sig: Signature) = SignedName(name.exclude(SignedName), sig)
   }
 }