Can be different explanations for not finding implicit, be more precise

Some small fixes

Author: NTPape

core/shared/src/main/scala-3.x/monocle/internal/focus/ErrorHandling.scala

@@ -21,8 +21,8 @@ private[focus] trait ErrorHandling {
     case FocusError.UnexpectedCodeStructure(code)             => s"Unexpected code structure: $code"
     case FocusError.CouldntFindFieldType(fromType, fieldName) => s"Couldn't find type for $fromType.$fieldName"
     case FocusError.InvalidDowncast(fromType, toType)         => s"Type '$fromType' could not be cast to '$toType'"
-    case FocusError.ImplicitNotFound(implicitType) =>
-      s"Could not find implicit for '$implicitType'. Note: implicits with default values are not supported."
+    case FocusError.ImplicitNotFound(implicitType, explanation) =>
+      s"Could not find (unique) implicit value for '$implicitType' due to $explanation. Note: implicits with default values are not supported."
     case FocusError.ExpansionFailed(reason) =>
       s"Case class with multiple parameter sets could not be expanded because of: $reason"
   }

core/shared/src/main/scala-3.x/monocle/internal/focus/FocusBase.scala

@@ -61,7 +61,7 @@ private[focus] trait FocusBase {
     case CouldntFindFieldType(fromType: String, fieldName: String)
     case ComposeMismatch(type1: String, type2: String)
     case InvalidDowncast(fromType: String, toType: String)
-    case ImplicitNotFound(implicitType: String)
+    case ImplicitNotFound(implicitType: String, explanation: String)
     case ExpansionFailed(reason: String)
 
     def asResult: FocusResult[Nothing] = Left(this)

core/shared/src/main/scala-3.x/monocle/internal/focus/features/SelectParserBase.scala

@@ -16,7 +16,7 @@ private[focus] trait SelectParserBase extends ParserBase {
     val companionObject: Term    = Ref(classSymbol.companionModule)
 
     private val (typeParams, caseFieldParams :: otherParams) =
-      classSymbol.primaryConstructor.paramSymss.span(_.head.isTypeParam)
+      classSymbol.primaryConstructor.paramSymss.span(_.headOption.fold(false)(_.isTypeParam))
     val hasOnlyOneCaseField: Boolean     = caseFieldParams.length == 1
     val hasOnlyOneParameterList: Boolean = otherParams.isEmpty
     private val nonCaseNonImplicitParameters: List[Symbol] =
@@ -32,7 +32,10 @@ private[focus] trait SelectParserBase extends ParserBase {
         case None         => FocusError.NotACaseField(typeRepr.show, fieldName).asResult
       }
     def getCaseFieldType(caseFieldSymbol: Symbol): FocusResult[TypeRepr] =
-      getFieldType(typeRepr, caseFieldSymbol)
+      caseFieldSymbol match {
+        case FieldType(possiblyTypeArg) => Right(swapWithSuppliedType(typeRepr, possiblyTypeArg))
+        case _                          => FocusError.CouldntFindFieldType(typeRepr.show, caseFieldSymbol.name).asResult
+      }
   }
 
   object CaseClassExtractor {
@@ -42,25 +45,19 @@ private[focus] trait SelectParserBase extends ParserBase {
       }
   }
 
-  def getSuppliedTypeArgs(fromType: TypeRepr): List[TypeRepr] =
+  private def getSuppliedTypeArgs(fromType: TypeRepr): List[TypeRepr] =
     fromType match {
       case AppliedType(_, argTypeReprs) => argTypeReprs
       case _                            => Nil
     }
 
-  def getFieldType(fromType: TypeRepr, caseFieldSymbol: Symbol): FocusResult[TypeRepr] =
-    caseFieldSymbol match {
-      case FieldType(possiblyTypeArg) => Right(swapWithSuppliedType(fromType, possiblyTypeArg))
-      case _                          => FocusError.CouldntFindFieldType(fromType.show, caseFieldSymbol.name).asResult
-    }
-
   private object FieldType {
     def unapply(fieldSymbol: Symbol): Option[TypeRepr] = fieldSymbol match {
       case sym if sym.isNoSymbol => None
       case sym =>
         sym.tree match {
           case ValDef(_, typeTree, _) => Some(typeTree.tpe)
-          // Only needed for Tuples because `_1` is a DefDef while `_1 ` is a ValDef.
+          // Only needed for Tuples because `_1` is a DefDef while `_1 ` is the corresponding ValDef.
           case DefDef(_, _, typeTree, _) => Some(typeTree.tpe)
           case _                         => None
         }
@@ -100,13 +97,13 @@ private[focus] trait SelectParserBase extends ParserBase {
               case (Right(acc), ValDef(_, t, _)) =>
                 def searchForImplicit(typeRepr: TypeRepr): FocusResult[Term] =
                   Implicits.search(typeRepr) match {
-                    case success: ImplicitSearchSuccess => Right(success.tree)
-                    case _                              => FocusError.ImplicitNotFound(typeRepr.show).asResult
+                    case success: ImplicitSearchSuccess =>
+                      Right(success.tree)
+                    case failure: ImplicitSearchFailure =>
+                      FocusError.ImplicitNotFound(typeRepr.show, failure.explanation).asResult
                   }
+
                 searchForImplicit(t.tpe)
-                  .orElse(searchForImplicit(t.tpe.dealias))
-                  .orElse(searchForImplicit(t.tpe.widen))
-                  .orElse(searchForImplicit(t.tpe.widen.dealias))
                   .map(acc :+ _)
 
               case (Right(acc), other) =>