Don't chain implicit conversions

When inferring a view, we are not allowed to use another
implicit conversion to adapt its result. Fixing this revealed
another problem where we have to re-enable implicit conversions
when pre-typing arguments in overloading resolution.

Author: odersky

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

@@ -1375,7 +1375,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
                 else WildcardType)
               val commonFormal = defn.FunctionOf(commonParamTypes, WildcardType)
               overload.println(i"pretype arg $arg with expected type $commonFormal")
-              pt.typedArg(arg, commonFormal)
+              pt.typedArg(arg, commonFormal)(ctx.addMode(Mode.ImplicitsEnabled))
             }
           }
         }

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

@@ -490,6 +490,7 @@ trait Implicits { self: Typer =>
         || (to isRef defn.UnitClass)
         || (from.tpe isRef defn.NothingClass)
         || (from.tpe isRef defn.NullClass)
+        || !(ctx.mode is Mode.ImplicitsEnabled)
         || (from.tpe eq NoPrefix)) NoImplicitMatches
     else
       try inferImplicit(to.stripTypeVar.widenExpr, from, from.pos)

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

@@ -2023,7 +2023,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       // try an implicit conversion
       inferView(tree, pt) match {
         case SearchSuccess(inferred, _, _, _) =>
-          adapt(inferred, pt)
+          adapt(inferred, pt)(ctx.retractMode(Mode.ImplicitsEnabled))
         case failure: SearchFailure =>
           if (pt.isInstanceOf[ProtoType] && !failure.isInstanceOf[AmbiguousImplicits]) tree
           else err.typeMismatch(tree, pt, failure)

compiler/test/dotty/tools/dotc/EntryPointsTest.scala.disabled

@@ -0,0 +1,5 @@
+// This used to take ~12s, the check should be that
+// it runs in reasonable time (i.e. instantaneous).
+object a {
+   val x: String | Int = 'a // error
+}