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 `ftypcon1.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 }
```

Before the change the two `Array[String]` and `Array[String]` point to
the same object, thus they go through the short-cut `tp1 eq tp2` in
`TypeComparer`, thus never reaches the line
`TypeComparer.compareAppliedType2`.

Author: liufengyun

compiler/test/dotty/tools/AnnotationsTests.scala

@@ -29,13 +29,20 @@ class AnnotationsTest:
         val arrayOfString = defn.ArrayType.appliedTo(List(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")
         }
       }