Various tests and test-fixes

Author: natsukagami

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

@@ -1832,7 +1832,7 @@ object desugar {
             cpy.ByNameTypeTree(parent)(annotate(tpnme.retainsByName, restpt))
           case _ =>
             annotate(tpnme.retains, parent)
-      case f: FunctionWithMods if f.erasedParams.contains(true) => makeFunctionWithValDefs(f, pt)
+      case f: FunctionWithMods if f.hasErasedParams => makeFunctionWithValDefs(f, pt)
     }
     desugared.withSpan(tree.span)
   }

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

@@ -80,6 +80,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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)
+
+      def hasErasedParams = erasedParams.contains(true)
     }
 
   /** A polymorphic function type */

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

@@ -2118,9 +2118,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         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
+    val erasedValid =
+      if tp1.hasErasedParams && tp2.hasErasedParams then
+        tp1.erasedParams == tp2.erasedParams
+      else !tp1.hasErasedParams && !tp2.hasErasedParams
 
     erasedValid && loop(tp1.paramInfos, tp2.paramInfos)
   }

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

@@ -647,11 +647,11 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
         erasureFn(sourceLanguage, semiEraseVCs, isConstructor, isSymbol, wildcardOK)(tpToErase)
-      val (names, formals0) = if (tp.hasErasedParams)
+      val (names, formals0) = if tp.hasErasedParams then
         tp.paramNames
           .zip(tp.paramInfos)
           .zip(tp.erasedParams)
-          .flatMap((p, e) => if e then None else Some(p))
+          .collect{ case (param, isErased) if !isErased => param }
           .unzip
       else (tp.paramNames, tp.paramInfos)
       val formals = formals0.mapConserve(paramErasure)

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

@@ -1851,8 +1851,7 @@ object Types {
         val funType = defn.FunctionOf(
           formals1 mapConserve (_.translateFromRepeated(toArray = isJava)),
           result1, isContextual, erasedParams)
-        if alwaysDependent || mt.isResultDependent then
-          RefinedType(funType, nme.apply, mt)
+        if alwaysDependent || mt.isResultDependent then RefinedType(funType, nme.apply, mt)
         else funType
     }
 
@@ -3702,7 +3701,7 @@ object Types {
             val params = if (hasErasedParams)
               tp.paramInfos
                 .zip(tp.erasedParams)
-                .flatMap((p, e) => if e then None else Some(p))
+                .collect { case (param, isErased) if !isErased => param }
             else tp.paramInfos
             resultSignature.prependTermParams(params, sourceLanguage)
           case tp: PolyType =>
@@ -4053,7 +4052,7 @@ object Types {
   }
 
   object MethodType extends MethodTypeCompanion("MethodType") {
-    def companion(isContextual: Boolean = false, isImplicit: Boolean = false, erasedParams: List[Boolean] = List()): MethodTypeCompanion =
+    def companion(isContextual: Boolean = false, isImplicit: Boolean = false, erasedParams: List[Boolean] = Nil): MethodTypeCompanion =
       val hasErased = erasedParams.contains(true)
       if (isContextual)
         if (hasErased) ErasedContextualMethodType(erasedParams) else ContextualMethodType

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -235,7 +235,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
         changePrec(GlobalPrec) {
           "("
           ~ keywordText("using ").provided(tp.isContextualMethod)
-          ~ keywordText("erased ").provided(tp.isErasedMethod)
           ~ keywordText("implicit ").provided(tp.isImplicitMethod && !tp.isContextualMethod)
           ~ paramsText(tp)
           ~ ")"

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -290,7 +290,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
         "[applied to ("
         ~ keywordText("using ").provided(tp.isContextualMethod)
-        ~ keywordText("erased ").provided(tp.isErasedMethod)
         ~ argsText
         ~ ") returning "
         ~ toText(resultType)

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2768,8 +2768,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def SomeModule: Symbol = dotc.core.Symbols.defn.SomeClass.companionModule
       def ProductClass: Symbol = dotc.core.Symbols.defn.ProductClass
       def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol =
-        if isErased
-        then dotc.core.Symbols.defn.ErasedFunctionClass
+        if isErased then dotc.core.Symbols.defn.ErasedFunctionClass
         else dotc.core.Symbols.defn.FunctionSymbol(arity, isImplicit)
       def TupleClass(arity: Int): Symbol =
         dotc.core.Symbols.defn.TupleType(arity).nn.classSymbol.asClass

tests/neg/safeThrowsStrawman2.scala

@@ -24,7 +24,7 @@ def bar(x: Boolean)(using CanThrow[Fail]): Int =
     val x = new CanThrow[Fail]()      // OK, x is erased
     val y: Any = new CanThrow[Fail]() // error: illegal reference to erased class CanThrow
     val y2: Any = new CTF()       // error: illegal reference to erased class CanThrow
-    println(foo(true, ctf))       // error: ctf is declared as erased, but is in fact used
+    println(foo(true, ctf))       // not error: ctf will be erased at erasure
     val a = (1, new CanThrow[Fail]()) // error: illegal reference to erased class CanThrow
     def b: (Int, CanThrow[Fail]) = ???
     def c = b._2                  // ok; we only check creation sites

tests/run-custom-args/erased/erased-27.check

@@ -1,3 +1,2 @@
 block
-x
 foo