Apply suggestions from code review

Co-authored-by: Nicolas Stucki <[email protected]>

Author: natsukagami

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -76,7 +76,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     override def isType: Boolean = body.isType
   }
 
-  /** A function type or closure with `implicit`, `erased`, or `given` modifiers */
+  /** A function type or closure with `implicit` or `given` modifiers and information on which parameters are `erased` */
   class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers, val erasedParams: List[Boolean])(implicit @constructorOnly src: SourceFile)
     extends Function(args, body) {
       assert(args.length == erasedParams.length)

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

@@ -2118,11 +2118,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/core/tasty/TastyPrinter.scala

@@ -136,7 +136,6 @@ class TastyPrinter(bytes: Array[Byte]) {
             case METHODtype | POLYtype | TYPELAMBDAtype =>
               printTree()
               while (currentAddr.index < end.index && !isModifierTag(nextByte)) { printTree(); printName(); }
-              // read tags
               printTrees()
             case PARAMtype =>
               printNat(); printNat()

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

@@ -3294,7 +3294,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/printing/PlainPrinter.scala

@@ -129,7 +129,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     * (hence with `GlobalPrec` precedence).
     */
   protected def argsText(args: List[Type]): Text =
-    atPrec(GlobalPrec) { Text(args.map(argText(_)), ", ") }
+    atPrec(GlobalPrec) { Text(args.map(arg => argText(arg) ), ", ") }
 
   /** The longest sequence of refinement types, starting at given type
    *  and following parents.

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

@@ -58,7 +58,7 @@ object ContextFunctionResults:
    */
   def contextResultsAreErased(sym: Symbol)(using Context): Boolean =
     def allErased(tp: Type): Boolean = tp.dealias match
-      case defn.ContextFunctionType(_, resTpe, erasedParams) => erasedParams.forall(_ == true) && allErased(resTpe)
+      case defn.ContextFunctionType(_, resTpe, erasedParams) => !erasedParams.contains(false) && allErased(resTpe)
       case _ => true
     contextResultCount(sym) > 0 && allErased(sym.info.finalResultType)
 

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

@@ -829,12 +829,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/transform/SpecializeFunctions.scala

@@ -70,7 +70,7 @@ class SpecializeFunctions extends MiniPhase {
   /** Dispatch to specialized `apply`s in user code when available */
   override def transformApply(tree: Apply)(using Context) =
     tree match {
-      case Apply(fun: NameTree, args) if fun.name == nme.apply && args.size <= 3 && fun.symbol.exists && fun.symbol.owner.isType =>
+      case Apply(fun: NameTree, args) if fun.name == nme.apply && args.size <= 3 && fun.symbol.maybeOwner.isType =>
         val argTypes = fun.tpe.widen.firstParamTypes.map(_.widenSingleton.dealias)
         val retType  = tree.tpe.widenSingleton.dealias
         val isSpecializable =

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

@@ -1248,7 +1248,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
@@ -1364,8 +1363,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)