Remove double lookup

Author: Jentsch

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

@@ -1387,11 +1387,11 @@ trait Applications extends Compatibility {
         // TODO: Maybe the 'reorder' method above can be reused, or be template
         if (bunchedArgs != Nil && argTypes != Nil) {
 
-          val typeInfoOfGetMethod =
-            if unapplyFn.tpe.widen.asInstanceOf[MethodType].resType.member(nme.get).exists then
-              unapplyFn.tpe.widen.asInstanceOf[MethodType].resType.member(nme.get).info
-            else
-              unapplyFn.tpe.widen.asInstanceOf[MethodType].resType
+          val resTypeOfUnapplyFn = unapplyFn.tpe.widen.asInstanceOf[MethodType].resType
+
+          val typeInfoOfGetMethod: Type =
+            resTypeOfUnapplyFn.member(nme.get).info
+                .orElse(resTypeOfUnapplyFn)
 
           val names = typeInfoOfGetMethod
             .memberDenots(typeNameFilter, (name, buf) => if (name.toString == "Names") buf += typeInfoOfGetMethod.member(name).asSingleDenotation)
@@ -2261,7 +2261,7 @@ trait Applications extends Compatibility {
    *  This reset is needed because otherwise the original results might
    *  have added constraints to type parameters which are no longer
    *  implied after harmonization. No essential constraints are lost by this because
-   *  the result of harmomization will be compared again with the expected type.
+   *  the result of harmonization will be compared again with the expected type.
    *  Test cases where this matters are in pos/harmomize.scala.
    */
   def harmonic[T](harmonize: List[T] => List[T], pt: Type)(op: => List[T])(using Context): List[T] =
@@ -2320,7 +2320,7 @@ trait Applications extends Compatibility {
    *  with the type parameters of the extension (T1, T2) inferred.
    *  None is returned if the implicit search fails for any of the leading implicit parameters
    *  or if the receiver has a wrong type (note that in general the type of the receiver
-   *  might depend on the exact types of the found instances of the proceding implicits).
+   *  might depend on the exact types of the found instances of the proceeding implicits).
    *  No implicit search is tried for implicits following the receiver or for parameters of the def (D, E).
    */
   def tryApplyingExtensionMethod(methodRef: TermRef, receiver: Tree)(using Context): Option[Tree] =