Optionally rewrite projections.

Author: odersky

src/dotty/tools/dotc/config/Config.scala

@@ -87,6 +87,15 @@ object Config {
   /** Check that certain types cannot be created in erasedTypes phases */
   final val checkUnerased = true
 
+  /** In `derivedSelect`, rewrite
+   *
+   *      (S & T)#A  -->  S#A & T#A
+   *      (S | T)#A  -->  S#A | T#A
+   *
+   *  Not sure whether this is useful. Preliminary measurements show a slowdown of about
+   *  7% for the build when this option is enabled.
+   */
+  final val splitProjections = false
 
   /** Initial size of superId table */
   final val InitialSuperIdsSize = 4096

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

@@ -1533,18 +1533,48 @@ object Types {
       ctx.underlyingRecursions -= 1
     }
 
+    /** A selection of the same kind, but with potentially a differet prefix.
+     *  The following normalizations are performed for type selections T#A:
+     *
+     *  1. If Config.splitProjections is true:
+     *
+     *     (S & T)#A --> S#A & T#A
+     *     (S | T)#A --> S#A | T#A
+     *
+     *  2. If A is bound to an alias `= B` in T
+     *
+     *     T#A --> B
+     */
     def derivedSelect(prefix: Type)(implicit ctx: Context): Type =
       if (prefix eq this.prefix) this
       else {
+        if (Config.splitProjections && isType)
+          prefix match {
+          case prefix: AndType =>
+            def isMissing(tp: Type) = tp match {
+              case tp: TypeRef => !tp.info.exists
+              case _ => false
+            }
+            val derived1 = derivedSelect(prefix.tp1)
+            val derived2 = derivedSelect(prefix.tp2)
+            return (
+              if (isMissing(derived1)) derived2
+              else if (isMissing(derived2)) derived1
+              else prefix.derivedAndType(derived1, derived2))
+          case prefix: OrType =>
+            val derived1 = derivedSelect(prefix.tp1)
+            val derived2 = derivedSelect(prefix.tp2)
+            return prefix.derivedOrType(derived1, derived2)
+          case _ =>
+        }
         val res = prefix.lookupRefined(name)
         if (res.exists) res
         else if (name == tpnme.hkApply && prefix.classNotLambda) {
           // After substitution we might end up with a type like
           // `C { type hk$0 = T0; ...; type hk$n = Tn } # $Apply`
           // where C is a class. In that case we eta expand `C`.
           derivedSelect(prefix.EtaExpandCore(this.prefix.typeConstructor.typeParams))
-        }
-        else newLikeThis(prefix)
+        } else newLikeThis(prefix)
       }
 
     /** Create a NamedType of the same kind as this type, but with a new prefix.