Abort implicit search for types with errors

If the searched-for type has errors, fail implicit search immediately.
Error types match everything, so we risk traversing many implicit
candidates for nothing.

This change uncovered the problem with parameter-dependent using
clauses with default arguments that was fixed in the last commit.

Author: odersky

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

@@ -332,13 +332,17 @@ object Types {
     /** Is this type produced as a repair for an error? */
     final def isError(using Context): Boolean = stripTypeVar.isInstanceOf[ErrorType]
 
+    /** A conservative approximation whether a type might have errors.
+     *  It's OK to predict "no errors" even though errors might be present.
+     *  But one should never force or loop.
+     */
     def hasErrors(using Context): Boolean = widenDealias match
-      case _: NamedType => false
       case AppliedType(tycon, args) => tycon.hasErrors || args.exists(_.hasErrors)
       case RefinedType(parent, _, rinfo) => parent.hasErrors || rinfo.hasErrors
       case TypeBounds(lo, hi) => lo.hasErrors || hi.hasErrors
       case tp: AndOrType => tp.tp1.hasErrors || tp.tp2.hasErrors
-      case tp: TypeProxy => tp.underlying.hasErrors
+      case tp: LambdaType => tp.resultType.hasErrors || tp.paramInfos.exists(_.hasErrors)
+      case WildcardType(optBounds) => optBounds.hasErrors
       case _: ErrorType => true
       case _ => false
 

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

@@ -455,7 +455,9 @@ trait Applications extends Compatibility {
     def success: Boolean = ok
 
     protected def methodType: MethodType = methType.asInstanceOf[MethodType]
-    private def methString: String = i"${err.refStr(methRef)}: ${methType.show}"
+    private def methString: String =
+      def infoStr = if methType.hasErrors then "" else i": $methType"
+      i"${err.refStr(methRef)}$infoStr"
 
     /** Re-order arguments to correctly align named arguments */
     def reorder[T >: Untyped](args: List[Trees.Tree[T]]): List[Trees.Tree[T]] = {

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

@@ -954,6 +954,10 @@ trait Implicits:
       assert(ctx.phase.allowsImplicitSearch,
         if (argument.isEmpty) i"missing implicit parameter of type $pt after typer"
         else i"type error: ${argument.tpe} does not conform to $pt${err.whyNoMatchStr(argument.tpe, pt)}")
+
+      if pt.hasErrors || !argument.isEmpty && argument.tpe.hasErrors then
+        return NoMatchingImplicitsFailure
+
       val result0 =
         try ImplicitSearch(pt, argument, span).bestImplicit
         catch case ce: CyclicReference =>

tests/neg/i7750a.scala

@@ -1,5 +1,5 @@
 def foo: Unit = {
     val a = (x: Int, y: String) => x + + y  // error
     implicit def f[X](x: (X,  String) => String) = (z: X) => (z, null) // error
-    a(1)
+    a(1) // error
 }