Clean up terminology

There are two concepts that were quite close but not exactly the same:

 - isErroneous, used if a type has errors in any part of it. Usually tested to
   not show a type with errors in it in diagnostics.
 - unusableForInference, used if a type (or its alias) has errors that make the
   type too undiscriminating for overloading resolution or implicit search.

Previously, we only used isErroneous in error diagnstics. Using it also for disabling
implicit search and resolutions ran into problems. Hence, the new predicate
unusableForInference.

Author: odersky

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

@@ -332,24 +332,28 @@ 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.
+    /** Is some part of the widened version of this type produced as a repair for an error?
+     *
      */
-    def hasErrors(using Context): Boolean = widenDealias match
-      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: LambdaType => tp.resultType.hasErrors || tp.paramInfos.exists(_.hasErrors)
-      case WildcardType(optBounds) => optBounds.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)
 
+    /** Is this type unusable for implicit search or overloading resolution
+     *  since it has embedded errors that can match anything? This is weaker and more
+     *  ad-hoc than isErroneous. The main differences are that we always consider aliases
+     *  (since these are relevant for inference or resolution) but never consider prefixes
+     *  (since these often do not constrain the search space anyway).
+     */
+    def unusableForInference(using Context): Boolean = widenDealias match
+      case AppliedType(tycon, args) => tycon.unusableForInference || args.exists(_.unusableForInference)
+      case RefinedType(parent, _, rinfo) => parent.unusableForInference || rinfo.unusableForInference
+      case TypeBounds(lo, hi) => lo.unusableForInference || hi.unusableForInference
+      case tp: AndOrType => tp.tp1.unusableForInference || tp.tp2.unusableForInference
+      case tp: LambdaType => tp.resultType.unusableForInference || tp.paramInfos.exists(_.unusableForInference)
+      case WildcardType(optBounds) => optBounds.unusableForInference
+      case _: ErrorType => true
+      case _ => false
+
     /** Does the type carry an annotation that is an instance of `cls`? */
     @tailrec final def hasAnnotation(cls: ClassSymbol)(using Context): Boolean = stripTypeVar match {
       case AnnotatedType(tp, annot) => (annot matches cls) || (tp hasAnnotation cls)

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

@@ -474,7 +474,7 @@ trait Applications extends Compatibility {
 
     protected def methodType: MethodType = methType.asInstanceOf[MethodType]
     private def methString: String =
-      def infoStr = if methType.hasErrors then "" else i": $methType"
+      def infoStr = if methType.isErroneous then "" else i": $methType"
       i"${err.refStr(methRef)}$infoStr"
 
     /** Re-order arguments to correctly align named arguments */
@@ -1944,7 +1944,7 @@ trait Applications extends Compatibility {
       case _ => false
 
     record("resolveOverloaded.narrowedApplicable", candidates.length)
-    if pt.hasErrors then
+    if pt.unusableForInference 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

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

@@ -955,8 +955,9 @@ trait Implicits:
         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
+      if pt.unusableForInference
+         || !argument.isEmpty && argument.tpe.unusableForInference
+      then return NoMatchingImplicitsFailure
 
       val result0 =
         try ImplicitSearch(pt, argument, span).bestImplicit

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

@@ -193,7 +193,11 @@ 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
+    override def isErroneous(using Context): Boolean =
+      memberProto.isErroneous
+
+    override def unusableForInference(using Context): Boolean =
+      memberProto.unusableForInference
 
     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)
@@ -405,7 +409,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 unusableForInference(using Context): Boolean =
+      state.typedArgs.exists(_.tpe.unusableForInference)
 
     override def toString: String = s"FunProto(${args mkString ","} => $resultType)"
 
@@ -457,7 +462,11 @@ 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
+    override def isErroneous(using Context): Boolean =
+      argType.isErroneous || resType.isErroneous
+
+    override def unusableForInference(using Context): Boolean =
+      argType.unusableForInference || resType.unusableForInference
 
     def map(tm: TypeMap)(using Context): ViewProto = derivedViewProto(tm(argType), tm(resultType))
 
@@ -502,7 +511,11 @@ 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)
+    override def isErroneous(using Context): Boolean =
+      targs.exists(_.tpe.isErroneous)
+
+    override def unusableForInference(using Context): Boolean =
+      targs.exists(_.tpe.unusableForInference)
 
     def map(tm: TypeMap)(using Context): PolyProto =
       derivedPolyProto(targs, tm(resultType))