Abort implicit search earlier if searched type is erroneous

 - Abort implicit search on erroneous arguments
 - Complete definitions of `isErroneous for various prototypes

Author: odersky

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

@@ -1948,7 +1948,7 @@ trait Applications extends Compatibility {
     if pt.isErroneous then
       // `pt` might have become erroneous by typing arguments of FunProtos.
       // If `pt` is erroneous, don't try to go further; report the error in `pt` instead.
-      candidates 
+      candidates
     else
       val found = narrowMostSpecific(candidates)
       if found.length <= 1 then found

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.isErroneous || argument.isEmpty && argument.tpe.isErroneous then
+        return NoMatchingImplicitsFailure
+
       val result0 =
         try ImplicitSearch(pt, argument, span).bestImplicit
         catch case ce: CyclicReference =>

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

@@ -124,6 +124,8 @@ object ProtoTypes {
     override def revealIgnored = ignored
     override def deepenProto(using Context): Type = ignored
 
+    override def isErroneous(using Context): Boolean = ignored.isErroneous
+
     override def computeHash(bs: Hashable.Binders): Int = doHash(bs, ignored)
 
     override def eql(that: Type): Boolean = that match
@@ -193,6 +195,9 @@ object ProtoTypes {
       if ((name eq this.name) && (memberProto eq this.memberProto) && (compat eq this.compat)) this
       else SelectionProto(name, memberProto, compat, privateOK)
 
+    override def isErroneous(using Context): Boolean =
+      memberProto.isErroneous
+
     def map(tm: TypeMap)(using Context): SelectionProto = derivedSelectionProto(name, tm(memberProto), compat)
     def fold[T](x: T, ta: TypeAccumulator[T])(using Context): T = ta(x, memberProto)
 
@@ -401,7 +406,7 @@ object ProtoTypes {
     def isDropped: Boolean = state.toDrop
 
     override def isErroneous(using Context): Boolean =
-      state.typedArgs.tpes.exists(_.isErroneous)
+      state.typedArgs.exists(_.tpe.isErroneous)
 
     override def toString: String = s"FunProto(${args mkString ","} => $resultType)"
 
@@ -453,6 +458,9 @@ object ProtoTypes {
       if ((argType eq this.argType) && (resultType eq this.resultType)) this
       else ViewProto(argType, resultType)
 
+    override def isErroneous(using Context): Boolean =
+      argType.isErroneous || resType.isErroneous
+
     def map(tm: TypeMap)(using Context): ViewProto = derivedViewProto(tm(argType), tm(resultType))
 
     def fold[T](x: T, ta: TypeAccumulator[T])(using Context): T =
@@ -496,6 +504,9 @@ object ProtoTypes {
       if ((targs eq this.targs) && (resType eq this.resType)) this
       else PolyProto(targs, resType)
 
+    override def isErroneous(using Context): Boolean =
+      targs.exists(_.tpe.isErroneous)
+
     def map(tm: TypeMap)(using Context): PolyProto =
       derivedPolyProto(targs, tm(resultType))
 

tests/run-bootstrapped/typeCheckErrors.check

@@ -1,2 +1 @@
 Error(Not found: abc,            1 + abc,16,Typer)
-Error(Not found: abc,            1 + abc,16,Typer)