Ignore implicit parameters when interpolating type variables.

Fixes scala#738.

The previous scheme interpolated type variables according to the
full variance of the result type. This means that the interpolation direction
is downwards if a type varaible occurs like this:

   (implicit x: T)T

but it is upwards if it occurs like this

   (implicit x: T)Unit

For a normal method this makes sense, since the upper bound of T gives
you the most general function. But if the method is implicit, it makes
no sense, since upward instantiation means that we likely get ambiguity
errors.

Interestingly the fix causes a different problem (exemplified by failures
in run/stream-stack-overflow.scala, and also in dotc itself), which will
be fixed in the next commit.

Author: odersky

src/dotty/tools/dotc/typer/Inferencing.scala

@@ -290,6 +290,14 @@ trait Inferencing { this: Checking =>
           if (v == null) vmap.updated(t, variance)
           else if (v == variance) vmap
           else vmap.updated(t, 0)
+        case t: ImplicitMethodType =>
+          // Assume type vars in implicit parameters are non-variant, in order not
+          // to widen them prematurely to upper bound if they don't occur in the result type.
+          val saved = variance
+          variance = 0
+          val vmap1 = foldOver(vmap, t.paramTypes)
+          variance = saved
+          this(vmap1, t.resultType)
         case _ =>
           foldOver(vmap, t)
       }