Use new error detector: hasErrors

It seems isErroneous forces too much. cats fails in mysterious ways if it is called in resolveOverloaded,
even if it always returns false. This commit uses an error detector instead that does not go via an accumulator,
so that we have more control what gets visited.

Author: odersky

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

@@ -332,6 +332,16 @@ object Types {
     /** Is this type produced as a repair for an error? */
     final def isError(using Context): Boolean = stripTypeVar.isInstanceOf[ErrorType]
 
+    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 _: ErrorType => true
+      case _ => false
+
     /** Is some part of the widened version of this type produced as a repair for an error? */
     def isErroneous(using Context): Boolean =
       widen.existsPart(_.isError, forceLazy = false)

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

@@ -1927,10 +1927,10 @@ trait Applications extends Compatibility {
       case _ => false
 
     record("resolveOverloaded.narrowedApplicable", candidates.length)
-    if pt.isErroneous then
+    if pt.hasErrors 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/ProtoTypes.scala

@@ -193,6 +193,8 @@ object ProtoTypes {
       if ((name eq this.name) && (memberProto eq this.memberProto) && (compat eq this.compat)) this
       else SelectionProto(name, memberProto, compat, privateOK)
 
+    override def hasErrors(using Context): Boolean = memberProto.hasErrors
+
     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)
 
@@ -403,6 +405,8 @@ object ProtoTypes {
     override def isErroneous(using Context): Boolean =
       state.typedArgs.tpes.exists(_.isErroneous)
 
+    override def hasErrors(using Context): Boolean = state.typedArgs.exists(_.tpe.hasErrors)
+
     override def toString: String = s"FunProto(${args mkString ","} => $resultType)"
 
     def map(tm: TypeMap)(using Context): FunProto =
@@ -453,6 +457,8 @@ object ProtoTypes {
       if ((argType eq this.argType) && (resultType eq this.resultType)) this
       else ViewProto(argType, resultType)
 
+    override def hasErrors(using Context): Boolean = argType.hasErrors || resType.hasErrors
+
     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 +502,8 @@ object ProtoTypes {
       if ((targs eq this.targs) && (resType eq this.resType)) this
       else PolyProto(targs, resType)
 
+    override def hasErrors(using Context): Boolean = targs.exists(_.tpe.hasErrors)
+
     def map(tm: TypeMap)(using Context): PolyProto =
       derivedPolyProto(targs, tm(resultType))