new type: TypeRef with a fixed sym and fixed info.

Linker uses it to represent types that normally would never have
escaped local scope(and thus have NoPrefix as prefix) that do
escape in Linker.

Eg, GenTraversableFactory has inner class GenericCanBuildFrom,
and anonymous instance of this class in field ReusableCBFInstance.

Linker needs to somehow see that the anonymous instance instantiated
in List$.ReusableCBFInstance is a subtype of List$.GenTraversableFactory
Thus it needs a valid prefix to participate in asSeenFrom and substThis.

Author: DarkDimius

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

@@ -1696,7 +1696,20 @@ object Types {
   }
 
   final class TermRefWithFixedSym(prefix: Type, name: TermName, val fixedSym: TermSymbol) extends TermRef(prefix, name) with WithFixedSym
-  final class TypeRefWithFixedSym(prefix: Type, name: TypeName, val fixedSym: TypeSymbol) extends TypeRef(prefix, name) with WithFixedSym
+  class TypeRefWithFixedSym(prefix: Type, name: TypeName, val fixedSym: TypeSymbol) extends TypeRef(prefix, name) with WithFixedSym
+
+  /* used by linker */
+  final class TypeRefWithFixedSymAndInfo(prefix: Type, name: TypeName, fixedSym: TypeSymbol, val underl: Type) extends TypeRefWithFixedSym(prefix, name, fixedSym) {
+    override def derivedSelect(prefix: Type)(implicit ctx: Context): Type =
+      if (prefix eq this.prefix) this
+      else {
+        ???
+    }
+
+    override def info(implicit ctx: Context): Type = underl
+
+    override def equals(that: Any): Boolean = that.isInstanceOf[TypeRefWithFixedSymAndInfo] && super.equals(that) && this.underl == that.asInstanceOf[TypeRefWithFixedSymAndInfo].underl
+  }
 
   /** Assert current phase does not have erasure semantics */
   private def assertUnerased()(implicit ctx: Context) =
@@ -1817,6 +1830,12 @@ object Types {
       unique(new TypeRefWithFixedSym(prefix, name, sym))
     }
 
+    def withFixedSymAndInfo(prefix: Type, name: TypeName, sym: TypeSymbol, info: Type)(implicit ctx: Context): TypeRef = {
+      if (Config.checkProjections) checkProjection(prefix, name)
+      unique(new TypeRefWithFixedSymAndInfo(prefix, name, sym, info))
+    }
+
+
     /** Create a type ref referring to given symbol with given name.
      *  This is very similar to TypeRef(Type, Symbol),
      *  except for two differences:
@@ -2027,7 +2046,7 @@ object Types {
 
   object AndType {
     def apply(tp1: Type, tp2: Type)(implicit ctx: Context) = {
-      assert(tp1.isInstanceOf[ValueType] && tp2.isInstanceOf[ValueType])
+      assert(tp1.isInstanceOf[ValueType] && tp2.isInstanceOf[ValueType], tp1.show +'\n' + tp2.show)
       unchecked(tp1, tp2)
     }
     def unchecked(tp1: Type, tp2: Type)(implicit ctx: Context) = {
@@ -2658,8 +2677,10 @@ object Types {
     def fullyAppliedRef(implicit ctx: Context): Type = fullyAppliedRef(cls.typeRef, cls.typeParams)
 
     def rebase(tp: Type)(implicit ctx: Context): Type =
-      if ((prefix eq cls.owner.thisType) || !cls.owner.isClass || ctx.erasedTypes) tp
-      else tp.substThis(cls.owner.asClass, prefix)
+      if ((prefix eq cls.owner.thisType) || (prefix eq NoPrefix) || ctx.erasedTypes) tp
+      else tp.substThis(cls.owner.enclosingClass.asClass, prefix) // enclosingClass is only needed in Linker.
+                                                                  // for typer originating from typer .owner should always
+                                                                  // be a class
 
     private var typeRefCache: Type = null