Scala.js: Add neg tests for bad uses of reflect.Selectable.

We add some infrastructure to be able to perform neg tests that are
specific to Scala.js. Such tests require the scalajs-library jar
and the dotty-libraryJS jar on the classpath, and must be compiled
with the `-scalajs` option.

We use this infrastructure to test existing compile errors reported
for unsupported uses of `reflect.Selectable` in Scala.js.

Author: sjrd

compiler/test/dotty/Properties.scala

@@ -48,6 +48,9 @@ object Properties {
   /** dotty-library jar */
   def dottyLibrary: String = sys.props("dotty.tests.classes.dottyLibrary")
 
+  /** dotty-library-js jar */
+  def dottyLibraryJS: String = sys.props("dotty.tests.classes.dottyLibraryJS")
+
   /** dotty-compiler jar */
   def dottyCompiler: String = sys.props("dotty.tests.classes.dottyCompiler")
 
@@ -74,4 +77,7 @@ object Properties {
 
   /** jline-reader jar */
   def jlineReader: String = sys.props("dotty.tests.classes.jlineReader")
+
+  /** scalajs-library jar */
+  def scalaJSLibrary: String = sys.props("dotty.tests.classes.scalaJSLibrary")
 }

compiler/test/dotty/tools/dotc/ScalaJSCompilationTests.scala

@@ -0,0 +1,40 @@
+package dotty
+package tools
+package dotc
+
+import org.junit.{ Test, BeforeClass, AfterClass }
+import org.junit.experimental.categories.Category
+
+import scala.concurrent.duration._
+import vulpix._
+
+@Category(Array(classOf[ScalaJSCompilationTests]))
+class ScalaJSCompilationTests extends ParallelTesting {
+  import ParallelTesting._
+  import TestConfiguration._
+  import ScalaJSCompilationTests._
+  import CompilationTest.aggregateTests
+
+  // Test suite configuration --------------------------------------------------
+
+  def maxDuration = 60.seconds
+  def numberOfSlaves = 5
+  def safeMode = Properties.testsSafeMode
+  def isInteractive = SummaryReport.isInteractive
+  def testFilter = Properties.testsFilter
+  def updateCheckFiles: Boolean = Properties.testsUpdateCheckfile
+
+  // Negative tests ------------------------------------------------------------
+
+  @Test def negScalaJS: Unit = {
+    implicit val testGroup: TestGroup = TestGroup("negScalaJS")
+    aggregateTests(
+      compileFilesInDir("tests/neg-scalajs", scalaJSOptions),
+    ).checkExpectedErrors()
+  }
+}
+
+object ScalaJSCompilationTests {
+  implicit val summaryReport: SummaryReporting = new SummaryReport
+  @AfterClass def cleanup(): Unit = summaryReport.echoSummary()
+}

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -44,6 +44,11 @@ object TestConfiguration {
   lazy val withTastyInspectorClasspath =
     withCompilerClasspath + File.pathSeparator + mkClasspath(List(Properties.dottyTastyInspector))
 
+  lazy val scalaJSClasspath = mkClasspath(List(
+    Properties.scalaJSLibrary,
+    Properties.dottyLibraryJS
+  ))
+
   def mkClasspath(classpaths: List[String]): String =
     classpaths.map({ p =>
       val file = new java.io.File(p)
@@ -61,6 +66,8 @@ object TestConfiguration {
     defaultOptions.withClasspath(withStagingClasspath).withRunClasspath(withStagingClasspath)
   lazy val withTastyInspectorOptions =
     defaultOptions.withClasspath(withTastyInspectorClasspath).withRunClasspath(withTastyInspectorClasspath)
+  lazy val scalaJSOptions =
+    defaultOptions.and("-scalajs").withClasspath(scalaJSClasspath)
   val allowDeepSubtypes = defaultOptions without "-Yno-deep-subtypes"
   val allowDoubleBindings = defaultOptions without "-Yno-double-bindings"
   val picklingOptions = defaultOptions and (

project/Build.scala

@@ -526,19 +526,22 @@ object Build {
           (sourceManaged in Compile).value
         }
         val externalDeps = externalCompilerClasspathTask.value
+        val externalJSDeps = (externalDependencyClasspath in (LocalProject("dotty-library-bootstrappedJS"), Compile)).value
         val jars = packageAll.value
 
         Seq(
           "-Ddotty.tests.dottyCompilerManagedSources=" + managedSrcDir,
           "-Ddotty.tests.classes.dottyInterfaces=" + jars("dotty-interfaces"),
           "-Ddotty.tests.classes.dottyLibrary=" + jars("dotty-library"),
+          "-Ddotty.tests.classes.dottyLibraryJS=" + jars("dotty-library-js"),
           "-Ddotty.tests.classes.dottyCompiler=" + jars("dotty-compiler"),
           "-Ddotty.tests.classes.tastyCore=" + jars("tasty-core"),
           "-Ddotty.tests.classes.compilerInterface=" + findArtifactPath(externalDeps, "compiler-interface"),
           "-Ddotty.tests.classes.scalaLibrary=" + findArtifactPath(externalDeps, "scala-library"),
           "-Ddotty.tests.classes.scalaAsm=" + findArtifactPath(externalDeps, "scala-asm"),
           "-Ddotty.tests.classes.jlineTerminal=" + findArtifactPath(externalDeps, "jline-terminal"),
           "-Ddotty.tests.classes.jlineReader=" + findArtifactPath(externalDeps, "jline-reader"),
+          "-Ddotty.tests.classes.scalaJSLibrary=" + findArtifactPath(externalJSDeps, "scalajs-library_2.13"),
         )
       },
 
@@ -705,7 +708,8 @@ object Build {
           // running the compiler, we should always have the bootstrapped
           // library on the compiler classpath since the non-bootstrapped one
           // may not be binary-compatible.
-          "dotty-library"       -> packageBin.in(`dotty-library-bootstrapped`, Compile).value
+          "dotty-library"       -> packageBin.in(`dotty-library-bootstrapped`, Compile).value,
+          "dotty-library-js"    -> packageBin.in(`dotty-library-bootstrappedJS`, Compile).value,
         ).mapValues(_.getAbsolutePath)
       }
     }.value,

tests/neg-scalajs/reflective-calls.scala

@@ -0,0 +1,45 @@
+import scala.reflect.{ClassTag, Selectable => ReflectSel}
+import ReflectSel.reflectiveSelectable
+
+object Test {
+  /* Make sure that an explicit desugaring of the legit cases actually compiles,
+   * ensuring that the error cases we test are actually testing the right things.
+   */
+  def sanityCheck(): Unit = {
+    val receiver: Any = ???
+    reflectiveSelectable(receiver).selectDynamic("foo") // OK
+    reflectiveSelectable(receiver).applyDynamic("foo")() // OK
+    reflectiveSelectable(receiver).applyDynamic("foo", ClassTag(classOf[String]), ClassTag(classOf[List[_]]))("bar", Nil) // OK
+  }
+
+  def badReceider(): Unit = {
+    val receiver: ReflectSel = ???
+    receiver.selectDynamic("foo") // error
+    receiver.applyDynamic("foo")() // error
+  }
+
+  def nonLiteralMethodName(): Unit = {
+    val receiver: Any = ???
+    val methodName: String = "foo"
+    reflectiveSelectable(receiver).selectDynamic(methodName) // error
+    reflectiveSelectable(receiver).applyDynamic(methodName)() // error
+  }
+
+  def nonLiteralClassTag(): Unit = {
+    val receiver: Any = ???
+    val myClassTag: ClassTag[String] = ClassTag(classOf[String])
+    reflectiveSelectable(receiver).applyDynamic("foo", myClassTag, ClassTag(classOf[List[_]]))("bar", Nil) // error
+  }
+
+  def classTagVarArgs(): Unit = {
+    val receiver: Any = ???
+    val classTags: List[ClassTag[_]] = List(ClassTag(classOf[String]), ClassTag(classOf[List[_]]))
+    reflectiveSelectable(receiver).applyDynamic("foo", classTags: _*)("bar", Nil) // error
+  }
+
+  def argsVarArgs(): Unit = {
+    val receiver: Any = ???
+    val args: List[Any] = List("bar", Nil)
+    reflectiveSelectable(receiver).applyDynamic("foo", ClassTag(classOf[String]), ClassTag(classOf[List[_]]))(args: _*) // error
+  }
+}