Fix test

We have the following subtyping result:

```scala
 Subtype trace:
    ==> Array#262[String#810] <:< Array#262[String#810]
	==> Array#262[String#810] <:< Array#262[String#810] recur
	<== Array#262[String#810] <:< Array#262[String#810] recur  = false
    <== Array#262[String#810] <:< Array#262[String#810]   = false
```

In `TypeComparer.compareAppliedType2`, the method just returns false
because `typcon2.typeParams` is empty:

```
  def compareAppliedType2(tp2: AppliedType, tycon2: Type, args2: List[Type]): Boolean = {
    val tparams = tycon2.typeParams
    if (tparams.isEmpty) return false
```

The reason why =typcon1.typeParams= is empty is because we are
running the subtyping check after erasure. The following code works
without any problem:

```scala
  atPhase(typerPhase) { arrayOfString =:= arg.tpe }
```

Author: liufengyun

compiler/test/dotty/tools/AnnotationsTests.scala

@@ -26,16 +26,23 @@ class AnnotationsTest:
         val defn = ctx.definitions
         val cls = requiredClass("A")
         val annotCls = requiredClass("Annot")
-        val arrayOfString = defn.ArrayType.appliedTo(List(defn.StringType))
+        val arrayOfString = defn.ArrayOf(defn.StringType)
 
         atPhase(erasurePhase.next) {
-          val annot = cls.getAnnotation(annotCls)
           // Even though we're forcing the annotation after erasure,
           // the typed trees should be unerased, so the type of
           // the annotation argument should be `arrayOfString` and
           // not a `JavaArrayType`.
+          val annot = cls.getAnnotation(annotCls)
           val arg = annot.get.argument(0).get
-          assert(arg.tpe.isInstanceOf[AppliedType] && arg.tpe =:= arrayOfString,
+
+          // If we run the type check after erasure, we will have
+          // `Array[String] =:= Array[String]` being false.
+          // The reason is that in `TypeComparer.compareAppliedType2` we have
+          // `tycon2.typeParams == Nil` after erasure, thus always get false.
+          val res = atPhase(typerPhase) { arrayOfString =:= arg.tpe }
+
+          assert(arg.tpe.isInstanceOf[AppliedType] && res,
             s"Argument $arg had type:\n${arg.tpe}\nbut expected type:\n$arrayOfString")
         }
       }