Use a general criterion for when to refer to symbols symbolically

Also

 - rename Fresh flag to NonMember
 - update criterion for phases where refs are symbolic. This used
   to be just before erasure (at resolveSuper) but then other phases
   were inserted after resolveSuper and the test became outdated. It's
   more robust now.

Author: odersky

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

@@ -359,7 +359,7 @@ object Phases {
       myErasedTypes  = prev.getClass == classOf[Erasure]      || prev.erasedTypes
       myFlatClasses  = prev.getClass == classOf[Flatten]      || prev.flatClasses
       myRefChecked   = prev.getClass == classOf[RefChecks]    || prev.refChecked
-      mySymbolicRefs = prev.getClass == classOf[ResolveSuper] || prev.symbolicRefs
+      mySymbolicRefs = getClass == classOf[Erasure] || prev.symbolicRefs
       myLabelsReordered = prev.getClass == classOf[LabelDefs] || prev.labelsReordered
       mySameMembersStartId = if (changesMembers) id else prev.sameMembersStartId
       mySameParentsStartId = if (changesParents) id else prev.sameMembersStartId

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

@@ -245,11 +245,15 @@ trait Symbols { this: Context =>
    *  would be `fld2`. There is a single local dummy per template.
    */
   def newLocalDummy(cls: Symbol, coord: Coord = NoCoord) =
-    newSymbol(cls, nme.localDummyName(cls), EmptyFlags, NoType)
+    newSymbol(cls, nme.localDummyName(cls), NonMember, 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 | NonMember, 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) =
@@ -343,7 +347,7 @@ trait Symbols { this: Context =>
         copy.denot = odenot.copySymDenotation(
           symbol = copy,
           owner = ttmap1.mapOwner(odenot.owner),
-          initFlags = odenot.flags &~ Touched | Fresh,
+          initFlags = odenot.flags &~ Touched,
           info = completer,
           privateWithin = ttmap1.mapOwner(odenot.privateWithin), // since this refers to outer symbols, need not include copies (from->to) in ownermap here.
           annotations = odenot.annotations)
@@ -436,8 +440,10 @@ object Symbols {
     final def asType(implicit ctx: Context): TypeSymbol = { assert(isType, s"isType called on not-a-Type $this"); asInstanceOf[TypeSymbol] }
     final def asClass: ClassSymbol = asInstanceOf[ClassSymbol]
 
-    final def isFresh(implicit ctx: Context) =
-      lastDenot != null && (lastDenot is Fresh)
+    final def isReferencedSymbolically(implicit ctx: Context) = {
+      val sym = lastDenot
+      sym != null && ((sym is NonMember) || sym.isTerm && ctx.phase.symbolicRefs)
+    }
 
     /** Special cased here, because it may be used on naked symbols in substituters */
     final def isStatic(implicit ctx: Context): Boolean =

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

@@ -2054,8 +2054,6 @@ object Types {
 
   object TermRef {
 
-    private def symbolicRefs(implicit ctx: Context) = ctx.phase.symbolicRefs
-
     /** 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.
@@ -2076,7 +2074,7 @@ object Types {
      *  signature, if denotation is not yet completed.
      */
     def apply(prefix: Type, name: TermName, denot: Denotation)(implicit ctx: Context): TermRef = {
-      if ((prefix eq NoPrefix) || denot.symbol.isFresh || symbolicRefs)
+      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically)
         apply(prefix, denot.symbol.asTerm)
       else denot match {
         case denot: SymDenotation if denot.isCompleted => withSig(prefix, name, denot.signature)
@@ -2098,7 +2096,7 @@ object Types {
      *  (2) The name in the term ref need not be the same as the name of the Symbol.
      */
     def withSymAndName(prefix: Type, sym: TermSymbol, name: TermName)(implicit ctx: Context): TermRef =
-      if ((prefix eq NoPrefix) || sym.isFresh || symbolicRefs)
+      if ((prefix eq NoPrefix) || sym.isReferencedSymbolically)
         withFixedSym(prefix, name, sym)
       else if (sym.defRunId != NoRunId && sym.isCompleted)
         withSig(prefix, name, sym.signature) withSym (sym, sym.signature)
@@ -2113,7 +2111,7 @@ object Types {
      *  (which must be completed).
      */
     def withSig(prefix: Type, sym: TermSymbol)(implicit ctx: Context): TermRef =
-      if ((prefix eq NoPrefix) || sym.isFresh || symbolicRefs) withFixedSym(prefix, sym.name, sym)
+      if ((prefix eq NoPrefix) || sym.isReferencedSymbolically) withFixedSym(prefix, sym.name, sym)
       else withSig(prefix, sym.name, sym.signature).withSym(sym, sym.signature)
 
     /** Create a term ref with given prefix, name and signature */
@@ -2122,7 +2120,7 @@ object Types {
 
     /** Create a term ref with given prefix, name, signature, and initial denotation */
     def withSigAndDenot(prefix: Type, name: TermName, sig: Signature, denot: Denotation)(implicit ctx: Context): TermRef = {
-      if ((prefix eq NoPrefix) || denot.symbol.isFresh || symbolicRefs)
+      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically)
         withFixedSym(prefix, denot.symbol.asTerm.name, denot.symbol.asTerm)
       else
         withSig(prefix, name, sig)
@@ -2151,12 +2149,12 @@ object Types {
      *  (2) The name in the type ref need not be the same as the name of the Symbol.
      */
     def withSymAndName(prefix: Type, sym: TypeSymbol, name: TypeName)(implicit ctx: Context): TypeRef =
-      if ((prefix eq NoPrefix) || sym.isFresh) withFixedSym(prefix, name, sym)
+      if ((prefix eq NoPrefix) || sym.isReferencedSymbolically) withFixedSym(prefix, name, sym)
       else apply(prefix, name).withSym(sym, Signature.NotAMethod)
 
     /** 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.isFresh) apply(prefix, denot.symbol.asType)
+      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically) apply(prefix, denot.symbol.asType)
       else apply(prefix, name)
     } withDenot denot
   }

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

@@ -983,7 +983,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
               UnApply(fn, implicitArgs, argPats, patType)
             case REFINEDtpt =>
               val refineCls = ctx.newCompleteClassSymbol(
-                ctx.owner, tpnme.REFINE_CLASS, Fresh, parents = Nil)
+                ctx.owner, tpnme.REFINE_CLASS, NonMember, parents = Nil)
               typeAtAddr(start) = refineCls.typeRef
               val parent = readTpt()
               val refinements = readStats(refineCls, end)(localContext(refineCls))

docs/docs/reference/union-intersection-subtyping.md

@@ -0,0 +1,15 @@
+
+### Subtyping Rules
+
+An intesection type `A & B` is a subtype of its constituents `A`, and `B`
+
+    A & B  <:  A
+    A & B  <:  B
+
+    T  <:  A & B    provided T <: A and T <: B
+
+If `C` is a covariant type constructor,
+
+    C[A & B]  =:=  C[A] & C[B]
+    C[A & B]  <:  C[B]
+