Minor architectural clean-up

compiler/src/dotty/tools/backend/sjs/JUnitBootstrappers.scala

@@ -229,8 +229,7 @@ class JUnitBootstrappers extends MiniPhase {
         val testAnnot = test.getAnnotation(junitdefn.TestAnnotClass).get
         if (testAnnot.arguments.nonEmpty)
           ctx.error("@Test annotations with arguments are not yet supported in Scala.js for dotty", testAnnot.tree.sourcePos)
-        val noArgConstr = junitdefn.TestAnnotType.member(nme.CONSTRUCTOR).suchThat(_.info.paramInfoss.head.isEmpty).symbol.asTerm
-        val reifiedAnnot = New(junitdefn.TestAnnotType, noArgConstr, Nil)
+        val reifiedAnnot = resolveConstructor(junitdefn.TestAnnotType, Nil)
         New(junitdefn.TestMetadataType, List(name, ignored, reifiedAnnot))
       }
       JavaSeqLiteral(metadata, TypeTree(junitdefn.TestMetadataType))
@@ -250,11 +249,7 @@ class JUnitBootstrappers extends MiniPhase {
         ValDef(castInstanceSym, instanceParamRef.cast(testClass.typeRef)) :: Nil,
         tests.foldRight[Tree] {
           val tp = junitdefn.NoSuchMethodExceptionType
-          val constr = tp.member(nme.CONSTRUCTOR).suchThat { c =>
-            c.info.paramInfoss.head.size == 1 &&
-            c.info.paramInfoss.head.head.isRef(defn.StringClass)
-          }.symbol.asTerm
-          Throw(New(tp, constr, nameParamRef :: Nil))
+          Throw(resolveConstructor(tp, nameParamRef :: Nil))
         } { (test, next) =>
           If(Literal(Constant(test.name.toString)).select(defn.Any_equals).appliedTo(nameParamRef),
             genTestInvocation(testClass, test, ref(castInstanceSym)),

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

@@ -1362,5 +1362,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
     transformer.transform(tree)
   }
+
+  def resolveConstructor(atp: Type, args:List[Tree])(implicit ctx: Context): Tree = {
+    val targs = atp.argTypes
+    tpd.applyOverloaded(New(atp.typeConstructor), nme.CONSTRUCTOR, args, targs, atp)
+  }
 }
 

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

@@ -115,15 +115,6 @@ object Annotations {
     def apply(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation =
       apply(New(atp, args))
 
-    private def resolveConstructor(atp: Type, args:List[Tree])(implicit ctx: Context): Tree = {
-      val targs = atp.argTypes
-      tpd.applyOverloaded(New(atp.typeConstructor), nme.CONSTRUCTOR, args, targs, atp)
-    }
-
-    def applyResolve(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation = {
-      apply(resolveConstructor(atp, args))
-    }
-
     /** Create an annotation where the tree is computed lazily. */
     def deferred(sym: Symbol)(treeFn: given Context => Tree)(implicit ctx: Context): Annotation =
       new LazyAnnotation {

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -934,11 +934,8 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       }
       t.toList
     }
-    // println(atp)
-    val targs = atp.argTypes
-
-    tpd.applyOverloaded(tpd.New(atp.typeConstructor), nme.CONSTRUCTOR, args, targs, atp)
-}
+    resolveConstructor(atp, args)
+  }
 
   /** Read an annotation and as a side effect store it into
    *  the symbol it requests. Called at top-level, for all