Apply suggestions from code review

Author: natsukagami

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

@@ -2117,11 +2117,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case nil =>
         formals2.isEmpty
     }
-    // Check if methods are erased, then the erased parameters match
-    val erasedValid =
-      if tp1.hasErasedParams && tp2.hasErasedParams then
-        tp1.erasedParams == tp2.erasedParams
-      else !tp1.hasErasedParams && !tp2.hasErasedParams
+    // If methods have erased parameters, then the erased parameters must match
+    val erasedValid = (!tp1.hasErasedParams && !tp2.hasErasedParams) || (tp1.erasedParams == tp2.erasedParams)
 
     erasedValid && loop(tp1.paramInfos, tp2.paramInfos)
   }

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

@@ -1473,7 +1473,7 @@ object Types {
 
     /** Dealias, and if result is a dependent function type, drop the `apply` refinement. */
     final def dropDependentRefinement(using Context): Type = dealias match {
-      case RefinedType(parent, nme.apply, mt) if !defn.isErasedFunctionType(parent) => parent
+      case RefinedType(parent, nme.apply, mt) if defn.isNonRefinedFunction(parent) => parent
       case tp => tp
     }
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3253,7 +3253,6 @@ object Parsers {
               val firstParamMod =
                 var mods = EmptyModifiers
                 if isErased then mods = addModifier(mods)
-                // if in.name == nme.inline then mods = addModifier(mods)
                 mods
               if givenOnly && !impliedMods.is(Given) then
                 syntaxError(em"`using` expected")

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

@@ -827,12 +827,10 @@ object Erasure {
       val Apply(fun, args) = tree
       val origFun = fun.asInstanceOf[tpd.Tree]
       val origFunType = origFun.tpe.widen(using preErasureCtx)
-      val erasedCompanion = if origFunType.hasErasedParams then
-        Some(origFunType.asInstanceOf[MethodType].erasedParams)
-      else None
-      val ownArgs = erasedCompanion.map { isErased =>
-        args.zip(isErased).collect { case (arg, isErased) if !isErased => arg }
-      }.getOrElse(args)
+      val ownArgs = origFunType match
+        case mt: MethodType if mt.hasErasedParams =>
+          args.zip(mt.erasedParams).collect { case (arg, false) => arg }
+        case _ => args
       val fun1 = typedExpr(fun, AnyFunctionProto)
       fun1.tpe.widen match
         case mt: MethodType =>

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

@@ -312,8 +312,7 @@ object GenericSignatures {
           // erased method parameters do not make it to the bytecode.
           def effectiveParamInfoss(t: Type)(using Context): List[List[Type]] = t match {
             case t: MethodType if t.hasErasedParams =>
-              t.paramInfos.zip(t.erasedParams)
-                .flatMap((i, e) => if e then None else Some(i))
+              t.paramInfos.zip(t.erasedParams).collect{ case (i, false) => i }
                 :: effectiveParamInfoss(t.resType)
             case t: MethodType => t.paramInfos :: effectiveParamInfoss(t.resType)
             case _ => Nil

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

@@ -39,10 +39,11 @@ class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
     else sym.copySymDenotation(initFlags = sym.flags | Private)
 
   override def transformApply(tree: Apply)(using Context): Tree =
-    if !tree.fun.tpe.widen.hasErasedParams then tree
-    else
-      val erasedParams = tree.fun.tpe.widen.asInstanceOf[MethodType].erasedParams
-      cpy.Apply(tree)(tree.fun, tree.args.zip(erasedParams).map((a, e) => if e then trivialErasedTree(a) else a))
+    tree.fun.tpe.widen match
+      case mt: MethodType if mt.hasErasedParams =>
+        cpy.Apply(tree)(tree.fun, tree.args.zip(mt.erasedParams).map((a, e) => if e then trivialErasedTree(a) else a))
+      case _ =>
+        tree
 
   override def transformValDef(tree: ValDef)(using Context): Tree =
     checkErasedInExperimental(tree.symbol)

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

@@ -1239,7 +1239,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val pt1 = pt.strippedDealias.normalized
     if (pt1 ne pt1.dropDependentRefinement)
        && defn.isContextFunctionType(pt1.nonPrivateMember(nme.apply).info.finalResultType)
-       && pt1.nonPrivateMember(nme.apply).info.asInstanceOf[MethodType].isResultDependent
     then
       report.error(
         em"""Implementation restriction: Expected result type $pt1
@@ -1354,8 +1353,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.span)
       val typeArgs = appDef.termParamss.head.map(_.tpt) :+ resTpt
       val core =
-        if mt.hasErasedParams
-        then TypeTree(defn.ErasedFunctionClass.typeRef)
+        if mt.hasErasedParams then TypeTree(defn.ErasedFunctionClass.typeRef)
         else
           val funSym = defn.FunctionSymbol(numArgs, isContextual, isImpure)
           val tycon = TypeTree(funSym.typeRef)