Remove ErasedMethodCompanions

We don't really need them, as we can fully rely on erased parameter annotations.
There is however a special case needed attention, where we infer the annotations of the type:

    def use(f: (erased Int) => Int): Int = f(5)

    val v = use { x => 5 }

Here `x` will be inferred to `Int @erasedParam`, which makes it an erased parameter, though
the user might have not intended to do.
We strip the annotated here, unless the user explicitly writes `erased x`.

Author: natsukagami

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

@@ -427,7 +427,7 @@ object Types {
     def isContextualMethod: Boolean = false
 
     /** Is this a MethodType for which the parameters will not be used? */
-    def hasErasedParams: Boolean = false
+    def hasErasedParams(using Context): Boolean = false
 
     /** Is this a match type or a higher-kinded abstraction of one?
      */
@@ -1182,7 +1182,8 @@ object Types {
 
     /** Remove all AnnotatedTypes wrapping this type.
      */
-    def stripAnnots(using Context): Type = this
+    def stripAnnots(keep: Annotation => Context ?=> Boolean)(using Context): Type = this
+    final def stripAnnots(using Context): Type = stripAnnots(_ => false)
 
     /** Strip TypeVars and Annotation and CapturingType wrappers */
     def stripped(using Context): Type = this
@@ -3913,26 +3914,14 @@ object Types {
     def companion: MethodTypeCompanion
 
     final override def isImplicitMethod: Boolean =
-      companion.eq(ImplicitMethodType) ||
-      companion.eq(ErasedImplicitMethodType) ||
-      isContextualMethod
-    final override def hasErasedParams: Boolean =
-      companion.isInstanceOf[ErasedMethodCompanion]
+      companion.eq(ImplicitMethodType) || isContextualMethod
+    final override def hasErasedParams(using Context): Boolean =
+      erasedParams.contains(true)
     final override def isContextualMethod: Boolean =
-      companion.eq(ContextualMethodType) ||
-      companion.eq(ErasedContextualMethodType)
-
-    override def erasedParams(using Context): List[Boolean] = companion match
-      case c: ErasedMethodCompanion => c.erasedParams(paramInfos)
-      case _ => super.erasedParams
-
-    /** Returns the corresponding companion, but without erased parameters */
-    final def companionWithoutErased = companion match
-      case ErasedImplicitMethodType => ImplicitMethodType
-      case ErasedContextualMethodType => ContextualMethodType
-      case ErasedMethodType => MethodType
-      case actual => actual
+      companion.eq(ContextualMethodType)
 
+    override def erasedParams(using Context): List[Boolean] =
+      paramInfos.map(p => p.hasAnnotation(defn.ErasedParamAnnot) || p.isErasedClass)
 
     protected def prefixString: String = companion.prefixString
   }
@@ -4046,31 +4035,13 @@ object Types {
   object MethodType extends MethodTypeCompanion("MethodType") {
     def companion(isContextual: Boolean = false, isImplicit: Boolean = false, erasedParams: List[Boolean] = Nil): MethodTypeCompanion =
       val hasErased = erasedParams.contains(true)
-      if (isContextual)
-        if (hasErased) ErasedContextualMethodType else ContextualMethodType
-      else if (isImplicit)
-        if (hasErased) ErasedImplicitMethodType else ImplicitMethodType
-      else
-        if (hasErased) ErasedMethodType else MethodType
-  }
-  sealed abstract class ErasedMethodCompanion(withoutErased: MethodTypeCompanion)
-    extends MethodTypeCompanion("Erased" + withoutErased.prefixString) {
-
-    override def apply(paramNames: List[TermName])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type)(using Context): MethodType =
-      val mt = super.apply(paramNames)(paramInfosExp, resultTypeExp)
-      // assert(erasedParams(mt.paramInfos).contains(true), s"$mt must contain an erased parameter")
-      if erasedParams(mt.paramInfos).contains(true) then mt
-      else withoutErased(paramNames)(paramInfosExp, resultTypeExp)
-
-    def erasedParams(paramsInfo: List[Type])(using Context) =
-      paramsInfo.map(p => p.hasAnnotation(defn.ErasedParamAnnot) || p.isErasedClass)
+      if (isContextual) ContextualMethodType
+      else if (isImplicit) ImplicitMethodType
+      else MethodType
   }
 
-  object ErasedMethodType extends ErasedMethodCompanion(MethodType)
   object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
-  object ErasedContextualMethodType extends ErasedMethodCompanion(ContextualMethodType)
   object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
-  object ErasedImplicitMethodType extends ErasedMethodCompanion(ImplicitMethodType)
 
   /** A ternary extractor for MethodType */
   object MethodTpe {
@@ -5285,7 +5256,10 @@ object Types {
     override def stripTypeVar(using Context): Type =
       derivedAnnotatedType(parent.stripTypeVar, annot)
 
-    override def stripAnnots(using Context): Type = parent.stripAnnots
+    override def stripAnnots(keep: Annotation => (Context) ?=> Boolean)(using Context): Type =
+      val p = parent.stripAnnots(keep)
+      if keep(annot) then derivedAnnotatedType(p, annot)
+      else p
 
     override def stripped(using Context): Type = parent.stripped
 

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -401,11 +401,7 @@ class TreeUnpickler(reader: TastyReader,
               readMethodic(_ => PolyType, _.toTypeName)
             case METHODtype =>
               def methodTypeCompanion(mods: FlagSet): MethodTypeCompanion =
-                if mods.is(Erased) then
-                  if mods.is(Implicit) then ErasedImplicitMethodType
-                  else if mods.is(Given) then ErasedContextualMethodType
-                  else ErasedMethodType
-                else if mods.is(Implicit) then ImplicitMethodType
+                if mods.is(Implicit) then ImplicitMethodType
                 else if mods.is(Given) then ContextualMethodType
                 else MethodType
               readMethodic(methodTypeCompanion, _.toTermName)

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

@@ -73,9 +73,7 @@ object ContextFunctionResults:
       case tp: MethodOrPoly =>
         tp.derivedLambdaType(resType = integrateContextResults(tp.resType, crCount))
       case defn.ContextFunctionType(argTypes, resType, erasedParams) =>
-        val methodType: MethodTypeCompanion =
-          if erasedParams.contains(true) then ErasedMethodType else MethodType
-        methodType(argTypes, integrateContextResults(resType, crCount - 1))
+        MethodType(argTypes, integrateContextResults(resType, crCount - 1))
 
   /** The total number of parameters of method `sym`, not counting
    *  erased parameters, but including context result parameters.

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

@@ -13,7 +13,6 @@ import ast.tpd
 import SymUtils._
 import config.Feature
 import Decorators.*
-import dotty.tools.dotc.core.Types.ErasedMethodCompanion
 import dotty.tools.dotc.core.Types.MethodType
 
 /** This phase makes all erased term members of classes private so that they cannot

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

@@ -1293,16 +1293,18 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *  If both attempts fail, return `NoType`.
    */
   def inferredFromTarget(
-      param: untpd.ValDef, formal: Type, calleeType: Type, paramIndex: Name => Int)(using Context): Type =
+      param: untpd.ValDef, formal: Type, calleeType: Type, isErased: Boolean, paramIndex: Name => Int)(using Context): Type =
     val target = calleeType.widen match
       case mtpe: MethodType =>
         val pos = paramIndex(param.name)
         if pos < mtpe.paramInfos.length then
-          mtpe.paramInfos(pos)
+          val tp = mtpe.paramInfos(pos)
             // This works only if vararg annotations match up.
             // See neg/i14367.scala for an example where the inferred type is mispredicted.
             // Nevertheless, the alternative would be to give up completely, so this is
             // defensible.
+          // Strip inferred erased annotation, to avoid accidentally inferring erasedness
+          if !isErased then tp.stripAnnots(_.symbol != defn.ErasedParamAnnot) else tp
         else NoType
       case _ => NoType
     if target.exists then formal <:< target
@@ -1534,11 +1536,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               // If the expected formal is a TypeBounds wildcard argument with Nothing as lower bound,
               // try to prioritize inferring from target. See issue 16405 (tests/run/16405.scala)
               val paramType =
+                // Strip inferred erased annotation, to avoid accidentally inferring erasedness
+                val formal0 = if !isErased then formal.stripAnnots(_.symbol != defn.ErasedParamAnnot) else formal
                 if knownFormal && !isBottomFromWildcard then
-                  formal
+                  formal0
                 else
-                  inferredFromTarget(param, formal, calleeType, paramIndex).orElse(
-                    if knownFormal then formal
+                  inferredFromTarget(param, formal, calleeType, isErased, paramIndex).orElse(
+                    if knownFormal then formal0
                     else errorType(AnonymousFunctionMissingParamType(param, tree, formal), param.srcPos)
                   )
               val paramTpt = untpd.TypedSplice(