Fix scala#6900: Support chained polymorphic extension methods

Given a tree `qual.foo`, when we typecheck `qual` we now that the result
must have a member named `foo`, if it doesn't we'll try to adapt it
through implicit conversion / extension method selection to something
which does have such a member.

Given a tree `qual.foo.bar`, the same process happens, but when we
perform the implicit conversion on `qual` we actually now more about
the member `foo`: it must have a member named `bar`, however in general
we cannot use this information: this member might actually require
another conversion and we don't chain conversions as a rule. Therefore,
we need to ignore the expected type of the member, this is implemented
by `ProtoTypes#selectionProto` wrapping the expected member type in
`IgnoredProto`.

However, the following failed before this commit:

    given bla[A] { def (a: A) foo[C]: C => A = _ => a }
    1.foo[String].foo[String]

This happens because when `Applications#extMethodApply` extracts the
type arguments of the extension method from its expected type, it might
end up unpealing an `IgnoredProto`. The solution is to rewrap the new
expeted type into an `IgnoredProto` if the original was ignored.

Author: smarter

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1837,13 +1837,19 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *   <methodRef>(<receiver>)    or
    *   <methodRef>[<type-args>](<receiver>)
    *
-   *  where <type-args> comes from `pt` if it is a PolyProto.
+   *  where <type-args> comes from `pt` if it is a (possibly ignored) PolyProto.
    */
   def extMethodApply(methodRef: untpd.Tree, receiver: Tree, pt: Type)(implicit ctx: Context) = {
-    val (core, pt1) = pt.revealIgnored match {
-      case PolyProto(targs, restpe) => (untpd.TypeApply(methodRef, targs.map(untpd.TypedSplice(_))), restpe)
-      case _ => (methodRef, pt)
+    def integrateTypeArgs(current: Type, wasIgnored: Boolean): (untpd.Tree, Type) = current match {
+      case IgnoredProto(ignored) =>
+        integrateTypeArgs(ignored, wasIgnored = true)
+      case PolyProto(targs, restpe) =>
+        val core = untpd.TypeApply(methodRef, targs.map(untpd.TypedSplice(_)))
+        (core, if (wasIgnored) IgnoredProto(restpe) else restpe)
+      case _ =>
+        (methodRef, pt)
     }
+    val (core, pt1) = integrateTypeArgs(pt, wasIgnored = false)
     val app =
       typed(untpd.Apply(core, untpd.TypedSplice(receiver) :: Nil), pt1, ctx.typerState.ownedVars)(
         ctx.addMode(Mode.SynthesizeExtMethodReceiver))