Small fixes

Author: NTPape

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
         }
@@ -103,10 +100,8 @@ private[focus] trait SelectParserBase extends ParserBase {
                     case success: ImplicitSearchSuccess => Right(success.tree)
                     case _                              => FocusError.ImplicitNotFound(typeRepr.show).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) =>