compare reading java from tasty with from classfile

Author: bishabosha

sbt-test/pipelining/Yjava-tasty-annotation/b-alt/.keep

@@ -11,3 +11,11 @@ lazy val b = project.in(file("b"))
     Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-annotation-java-tasty.jar")),
     scalacOptions += "-Ycheck:all",
   )
+
+// same as b, but adds the real classes to the classpath instead of the tasty jar
+lazy val bAlt = project.in(file("b-alt"))
+  .settings(
+    Compile / sources := (b / Compile / sources).value,
+    Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-annotation-classes")),
+    scalacOptions += "-Ycheck:all",
+  )

sbt-test/pipelining/Yjava-tasty-annotation/build.sbt

@@ -1,3 +1,5 @@
 > a/compile
 # Test depending on a java compiled annotation through TASTy
 > b/compile
+# double check against the real java classes
+> bAlt/compile

sbt-test/pipelining/Yjava-tasty-annotation/test

@@ -17,3 +17,15 @@ lazy val b = project.in(file("b"))
     fork := true, // we have to fork the JVM if we actually want to run the code with correct failure semantics
     Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-enum-classes"), // make sure the java classes are visible at runtime
   )
+
+// same as b, but adds the real classes to the classpath instead of the tasty jar
+lazy val bAlt = project.in(file("b-alt"))
+  .settings(
+    Compile / sources := (b / Compile / sources).value,
+    Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-enum-classes")),
+    scalacOptions += "-Ycheck:all",
+  )
+  .settings(
+    fork := true, // we have to fork the JVM if we actually want to run the code with correct failure semantics
+    Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-enum-classes"), // make sure the java classes are visible at runtime
+  )

sbt-test/pipelining/Yjava-tasty-enum/b-alt/.keep

@@ -1,3 +1,5 @@
 > a/compile
 # test depending on a java compiled enum through TASTy
 > b/run
+# double check against the real java classes
+> bAlt/run

sbt-test/pipelining/Yjava-tasty-enum/build.sbt

@@ -33,3 +33,17 @@ lazy val b = project.in(file("b"))
     // make sure the java classes are visible at runtime
     Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-pre-classes"),
   )
+
+// same as b, but adds the real classes to the classpath instead of the tasty jar
+lazy val bAlt = project.in(file("b-alt"))
+  .settings(
+    scalacOptions += "-Ycheck:all",
+    Compile / sources := (b / Compile / sources).value,
+    Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-pre-classes")),
+  )
+  .settings(
+    // we have to fork the JVM if we actually want to run the code with correct failure semantics
+    fork := true,
+    // make sure the java classes are visible at runtime
+    Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-pre-classes"),
+  )

sbt-test/pipelining/Yjava-tasty-enum/test

@@ -3,3 +3,5 @@
 > a_from_tasty/compile
 # test java tasty is still written even with -from-tasty
 > b/run
+# double check against the real java classes
+> bAlt/run

sbt-test/pipelining/Yjava-tasty-from-tasty/b-alt/.keep

@@ -15,3 +15,15 @@ lazy val b = project.in(file("b"))
     fork := true, // we have to fork the JVM if we actually want to run the code with correct failure semantics
     Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-generic-classes"), // make sure the java classes are visible at runtime
   )
+
+// same as b, but adds the real classes to the classpath instead of the tasty jar
+lazy val bAlt = project.in(file("b-alt"))
+  .settings(
+    Compile / sources := (b / Compile / sources).value,
+    Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-generic-classes")),
+    scalacOptions += "-Ycheck:all",
+  )
+  .settings(
+    fork := true, // we have to fork the JVM if we actually want to run the code with correct failure semantics
+    Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-generic-classes"), // make sure the java classes are visible at runtime
+  )

sbt-test/pipelining/Yjava-tasty-from-tasty/build.sbt

@@ -1,3 +1,5 @@
 > a/compile
 # Test depending on a java generic class through TASTy
 > b/run
+# double check against the real java classes
+> bAlt/run

sbt-test/pipelining/Yjava-tasty-from-tasty/test

@@ -15,3 +15,15 @@ lazy val b = project.in(file("b"))
     fork := true, // we have to fork the JVM if we actually want to run the code with correct failure semantics
     Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-result-types-classes"), // make sure the java classes are visible at runtime
   )
+
+// same as b, but adds the real classes to the classpath instead of the tasty jar
+lazy val bAlt = project.in(file("b-alt"))
+  .settings(
+    Compile / sources := (b / Compile / sources).value,
+    Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-result-types-classes")),
+    scalacOptions += "-Ycheck:all",
+  )
+  .settings(
+    fork := true, // we have to fork the JVM if we actually want to run the code with correct failure semantics
+    Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-result-types-classes"), // make sure the java classes are visible at runtime
+  )

sbt-test/pipelining/Yjava-tasty-generic/b-alt/.keep

@@ -1,3 +1,5 @@
 > a/compile
 # Test depending on a java static final result, and method result through TASTy
 > b/run
+# double check against the real java classes
+> bAlt/run