~/code/scala git diff
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index d87090f..d1d6384 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -386,38 +386,7 @@ trait Implicits {
      *  Two types overlap if they have the same type symbol, or
      *  if one or both are intersection types with a pair of overlapping parent types.
      */
-    private def dominates(dtor: Type, dted: Type): Boolean = {
-      def core(tp: Type): Type = tp.dealiasWiden match {
-        case RefinedType(parents, defs)         => intersectionType(parents map core, tp.typeSymbol.owner)
-        case AnnotatedType(annots, tp)          => core(tp)
-        case ExistentialType(tparams, result)   => core(result).subst(tparams, tparams map (t => core(t.info.bounds.hi)))
-        case PolyType(tparams, result)          => core(result).subst(tparams, tparams map (t => core(t.info.bounds.hi)))
-        case _                                  => tp
-      }
-      def stripped(tp: Type): Type = {
-        // `t.typeSymbol` returns the symbol of the normalized type. If that normalized type
-        // is a `PolyType`, the symbol of the result type is collected. This is precisely
-        // what we require for SI-5318.
-        val syms = for (t <- tp; if t.typeSymbol.isTypeParameter) yield t.typeSymbol
-        deriveTypeWithWildcards(syms.distinct)(tp)
-      }
-      def complexity(tp: Type): Int = tp.dealias match {
-        case NoPrefix                => 0
-        case SingleType(pre, sym)    => if (sym.hasPackageFlag) 0 else complexity(tp.dealiasWiden)
-        case ThisType(sym)           => if (sym.hasPackageFlag) 0 else 1
-        case TypeRef(pre, sym, args) => complexity(pre) + (args map complexity).sum + 1
-        case RefinedType(parents, _) => (parents map complexity).sum + 1
-        case _                       => 1
-      }
-      def overlaps(tp1: Type, tp2: Type): Boolean = (tp1, tp2) match {
-        case (RefinedType(parents, _), _) => parents exists (overlaps(_, tp2))
-        case (_, RefinedType(parents, _)) => parents exists (overlaps(tp1, _))
-        case _                            => tp1.typeSymbol == tp2.typeSymbol
-      }
-      val dtor1 = stripped(core(dtor))
-      val dted1 = stripped(core(dted))
-      overlaps(dtor1, dted1) && (dtor1 =:= dted1 || complexity(dtor1) > complexity(dted1))
-    }
+    private def dominates(dtor: Type, dted: Type): Boolean = false

     /** The expected type with all undetermined type parameters replaced with wildcards. */
     def approximate(tp: Type) = deriveTypeWithWildcards(undetParams)(tp)

commit 11c58a468d3041d1320c7d749dd9a29caf4564da (HEAD, origin/master, origin/HEAD, master)
Merge: 6c7d503 e2ece2f
Author: Stefan Zeiger <szeiger@novocode.com>
Date:   Wed Jan 22 07:20:55 2014 -0800

    Merge pull request #617 from slick/tmp/consistent-doc-versions

    Pass Slick version properly from sbt into Sphinx.

  ~/code/slick sbt slick/test:console
...
scala> import scala.reflect.ClassTag
import scala.reflect.ClassTag

scala> import scala.slick.ast.{TypedType}
import scala.slick.ast.TypedType

scala> import scala.slick.lifted.FlatShapeLevel
<console>:9: error: object FlatShapeLevel is not a member of package scala.slick.lifted
       import scala.slick.lifted.FlatShapeLevel
              ^

scala> import scala.slick.lifted.Shape
import scala.slick.lifted.Shape

scala> import scala.slick.collection.heterogenous._
import scala.slick.collection.heterogenous._

scala> trait Tables {
     |   implicit def stringColumnType: TypedType[String] = ???
     |   type BranchRow = HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HCons[String,HNil.type]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
     |
     |   implicitly[Shape[_ <: FlatShapeLevel, BranchRow, BranchRow, _]]
     |   def x = implicitly[Shape[_ <: FlatShapeLevel, HCons[String,HNil.type], _, _]]
     |   val i = x
     | }
<console>:18: error: not found: type FlatShapeLevel
         def x = implicitly[Shape[_ <: FlatShapeLevel, HCons[String,HNil.type], _, _]]
                                       ^
<console>:17: error: not found: type FlatShapeLevel
         implicitly[Shape[_ <: FlatShapeLevel, BranchRow, BranchRow, _]]
                               ^

Jason: Just to refresh my memory: this project shows code that is fast with 2.10.4 but slow with 2.11.x

cvogt: no. Slow with 2.10.4
removing this line makes it fast: https://github.com/cvogt/slick-presentation/blob/tmp/hlistSpeed/src/main/scala/SlickPresentation.scala#L12
which is odd
that's the problem.
why does this line make it slow?

Jason: Okay, then maybe there are two problems that this exposes...
I'm bisecting the problem that it is massively slow in 2.11

It got slow after this "refactoring": https://github.com/scala/scala/commit/9c09c170998f74fba03990977b285e3121db32a6#diff-7c03397456d3b987549fd039d6b639c6L667
But I remember that line, and it was since reverted as part of SI-6966
so I need to see if it sped up again at that point...
sigh...

cvogt: thanks man :-\

Jason: The reversion, https://github.com/scala/scala/commit/58bfa19, doesn't restore performance. Maybe that line wasn't the culprit.