Do not dealias in FunctionNOf extractor

Author: nicolasstucki

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -408,9 +408,9 @@ class CheckCaptures extends Recheck, SymTransformer:
       else if meth == defn.Caps_unsafeUnbox then
         mapArgUsing(_.forceBoxStatus(false))
       else if meth == defn.Caps_unsafeBoxFunArg then
-        mapArgUsing:
-          case defn.FunctionOf(mt: MethodType) if !mt.isResultDependent =>
-            defn.FunctionOf(mt.derivedLambdaType(resType = mt.resType.forceBoxStatus(true)))
+        mapArgUsing: tp =>
+          val defn.FunctionOf(mt: MethodType) = tp.dealias: @unchecked
+          defn.FunctionOf(mt.derivedLambdaType(resType = mt.resType.forceBoxStatus(true)))
       else
         super.recheckApply(tree, pt) match
           case appType @ CapturingType(appType1, refs) =>
@@ -704,7 +704,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           if eparent1 eq eparent then expected
           else CapturingType(eparent1, refs, boxed = expected0.isBoxed)
         case defn.FunctionOf(mt: MethodType) =>
-          actual match
+          actual.dealias match
             case defn.FunctionOf(mt2: MethodType) if mt2.isResultDependent =>
               mt.toFunctionType(isJava = false, alwaysDependent = true)
             case _ =>

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

@@ -1141,11 +1141,10 @@ class Definitions {
     /** Matches a (possibly aliased) `FunctionN[...]` or `ContextFunctionN[...]`.
      *  Extracts the list of function argument types, the result type and whether function is contextual.
      */
-    def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean)] = {
-      val dft = ft.dealias
-      val tsym = dft.typeSymbol
-      if isFunctionSymbol(tsym) && ft.isRef(tsym) then
-        val targs = dft.argInfos
+    def unapply(tpe: Type)(using Context): Option[(List[Type], Type, Boolean)] = {
+      val tsym = tpe.typeSymbol
+      if isFunctionSymbol(tsym) && tpe.isRef(tsym) then
+        val targs = tpe.argInfos
         if (targs.isEmpty) None
         else Some(targs.init, targs.last, tsym.name.isContextFunction)
       else None

compiler/src/dotty/tools/dotc/transform/Bridges.scala

@@ -130,7 +130,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
           ctx.typer.typed(untpd.cpy.Apply(ref)(ref, args), member.info.finalResultType)
         else
           val mtWithoutErasedParams = atPhase(erasurePhase) {
-            tp match
+            tp.dealias match
               case defn.FunctionOf(mt: MethodType) =>
                 val paramInfos = mt.paramInfos.zip(mt.erasedParams).collect { case (param, false) => param }
                 mt.derivedLambdaType(paramInfos = paramInfos)

compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala

@@ -19,7 +19,7 @@ object ContextFunctionResults:
    *  consists of a string of `n` nested context closures.
    */
   def annotateContextResults(mdef: DefDef)(using Context): Unit =
-    def contextResultCount(rhs: Tree, tp: Type): Int = tp match
+    def contextResultCount(rhs: Tree, tp: Type): Int = tp.dealias match
       case defn.FunctionOf(mt) if mt.isContextualMethod =>
         rhs match
           case closureDef(meth) => 1 + contextResultCount(meth.rhs, mt.resType)
@@ -68,7 +68,7 @@ object ContextFunctionResults:
    */
   def integrateContextResults(tp: Type, crCount: Int)(using Context): Type =
     if crCount == 0 then tp
-    else tp match
+    else tp.dealias match
       case ExprType(rt) =>
         integrateContextResults(rt, crCount)
       case tp: MethodOrPoly =>
@@ -113,7 +113,7 @@ object ContextFunctionResults:
     else tree match
       case Select(qual, name) =>
         if name == nme.apply then
-          qual.tpe match
+          qual.tpe.nn.dealias match
             case defn.FunctionOf(mt) if mt.isContextualMethod =>
               integrateSelect(qual, n + 1)
             case _ if defn.isContextFunctionClass(tree.symbol.maybeOwner) => // for TermRefs

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

@@ -1974,7 +1974,7 @@ trait Applications extends Compatibility {
         def paramCount(ref: TermRef) =
           val formals = ref.widen.firstParamTypes
           if formals.length > idx then
-            formals(idx) match
+            formals(idx).dealias match
               case defn.FunctionNOf(args, _, _) => args.length
               case _ => -1
           else -1
@@ -2060,7 +2060,7 @@ trait Applications extends Compatibility {
           else resolveMapped(alts1, _.widen.appliedTo(targs1.tpes), pt1)
 
       case pt =>
-        val compat0 = pt match
+        val compat0 = pt.dealias match
           case defn.FunctionNOf(args, resType, _) =>
             narrowByTypes(alts, args, resType)
           case _ =>

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

@@ -166,7 +166,7 @@ object ErrorReporting {
       val normTp = normalize(tree.tpe, pt)
       val normPt = normalize(pt, pt)
 
-      def contextFunctionCount(tp: Type): Int = tp.stripped match
+      def contextFunctionCount(tp: Type): Int = tp.stripped.dealias match
         // TODO handle result-dependent functions?
         case defn.FunctionOf(mt) if mt.isContextualMethod && !mt.isResultDependent => 1 + contextFunctionCount(mt.resType)
         case _ => 0

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

@@ -1892,7 +1892,7 @@ class Namer { typer: Typer =>
     def expectedDefaultArgType =
       val originalTp = defaultParamType
       val approxTp = wildApprox(originalTp)
-      approxTp.stripPoly match
+      approxTp.dealias.stripPoly match
         case defn.FunctionOf(mt)
         if mt.isContextualMethod && (
            mt.isResultDependent || // in this case `resType` is lying, gives us only the non-dependent upper bound

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

@@ -383,7 +383,7 @@ object ProtoTypes {
     def allArgTypesAreCurrent()(using Context): Boolean =
       state.typedArg.size == args.length
 
-    private def isUndefined(tp: Type): Boolean = tp match {
+    private def isUndefined(tp: Type): Boolean = tp.dealias match {
       case _: WildcardType => true
       case defn.FunctionNOf(args, result, _) => args.exists(isUndefined) || isUndefined(result)
       case _ => false