Use typeChecks directly where possible

Author: nicolasstucki

scalatest.dotty/src/main/scala/org/scalatest/Assertions.scala

@@ -27,6 +27,7 @@ import org.scalatest.exceptions.TestFailedException
 import org.scalatest.exceptions.TestPendingException
 import org.scalactic.anyvals.NonEmptyArray
 import scala.quoted._
+import scala.compiletime.testing.typeChecks
 import org.scalatest.compatible.Assertion
 import ArrayHelper.deep
 
@@ -660,7 +661,7 @@ trait Assertions extends TripleEquals  {
    * @param code the snippet of code that should not type check
    */
   inline def assertTypeError(inline code: String)(implicit pos: source.Position): Assertion =
-    ${ CompileMacro.assertTypeErrorImpl(code, '{ pos }) }
+    ${ CompileMacro.assertTypeErrorImpl('code, typeChecks(code), '{ pos }) }
 
   /**
    * Asserts that a given string snippet of code does not pass either the Scala parser or type checker.
@@ -692,7 +693,7 @@ trait Assertions extends TripleEquals  {
    * @param code the snippet of code that should not type check
    */
   inline def assertDoesNotCompile(inline code: String)(implicit pos: source.Position): Assertion =
-    ${ CompileMacro.assertDoesNotCompileImpl(code, '{ pos }) }
+    ${ CompileMacro.assertDoesNotCompileImpl('code, typeChecks(code), 'pos) }
 
   /**
    * Asserts that a given string snippet of code passes both the Scala parser and type checker.
@@ -714,7 +715,7 @@ trait Assertions extends TripleEquals  {
    * @param code the snippet of code that should compile
    */
   inline def assertCompiles(inline code: String)(implicit pos: source.Position): Assertion =
-    ${ CompileMacro.assertCompilesImpl(code, '{ pos }) }
+    ${ CompileMacro.assertCompilesImpl('code, typeChecks(code), 'pos) }
 
   /**
    * Intercept and return an exception that's expected to

scalatest.dotty/src/main/scala/org/scalatest/CompileMacro.scala

@@ -23,22 +23,22 @@ import scala.quoted._
 object CompileMacro {
 
   // parse and type check a code snippet, generate code to throw TestFailedException when type check passes or parse error
-  def assertTypeErrorImpl(code: String, pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] = {
+  def assertTypeErrorImpl(code: Expr[String], typeChecked: Boolean, pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] = {
     import qctx.tasty._
 
-    if (!typing.typeChecks(code)) '{ Succeeded }
+    if (!typeChecked) '{ Succeeded }
     else '{
-      val messageExpr = Resources.expectedTypeErrorButGotNone(${ code.toExpr })
+      val messageExpr = Resources.expectedTypeErrorButGotNone($code)
       throw new TestFailedException((_: StackDepthException) => Some(messageExpr), None, $pos)
     }
   }
 
-  def expectTypeErrorImpl(code: String, prettifier: Expr[Prettifier], pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Fact] = {
+  def expectTypeErrorImpl(code: Expr[String], typeChecked: Boolean, prettifier: Expr[Prettifier], pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Fact] = {
     import qctx.tasty._
 
-    if (typing.typeChecks(code))
+    if (typeChecked)
       '{
-          val messageExpr = Resources.expectedTypeErrorButGotNone(${ code.toExpr })
+          val messageExpr = Resources.expectedTypeErrorButGotNone($code)
           Fact.No(
             messageExpr,
             messageExpr,
@@ -52,7 +52,7 @@ object CompileMacro {
        }
     else
       '{
-          val messageExpr = Resources.gotTypeErrorAsExpected(${ code.toExpr })
+          val messageExpr = Resources.gotTypeErrorAsExpected($code)
 
           Fact.Yes(
             messageExpr,
@@ -68,23 +68,23 @@ object CompileMacro {
   }
 
   // parse and type check a code snippet, generate code to throw TestFailedException when both parse and type check succeeded
-  def assertDoesNotCompileImpl(code: String, pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] = {
+  def assertDoesNotCompileImpl(code: Expr[String], typeChecked: Boolean, pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] = {
     import qctx.tasty._
 
-    if (!typing.typeChecks(code)) '{ Succeeded }
+    if (!typeChecked) '{ Succeeded }
     else '{
-      val messageExpr = Resources.expectedCompileErrorButGotNone(${ code.toExpr })
+      val messageExpr = Resources.expectedCompileErrorButGotNone($code)
       throw new TestFailedException((_: StackDepthException) => Some(messageExpr), None, $pos)
     }
   }
 
   // parse and type check a code snippet, generate code to return Fact (Yes or No).
-  def expectDoesNotCompileImpl(code: String, prettifier: Expr[Prettifier], pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Fact] = {
+  def expectDoesNotCompileImpl(code: Expr[String], typeChecked: Boolean, prettifier: Expr[Prettifier], pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Fact] = {
     import qctx.tasty._
 
-    if (typing.typeChecks(code))
+    if (typeChecked)
       '{
-          val messageExpr = Resources.expectedCompileErrorButGotNone(${ code.toExpr })
+          val messageExpr = Resources.expectedCompileErrorButGotNone($code)
           Fact.No(
             messageExpr,
             messageExpr,
@@ -98,7 +98,7 @@ object CompileMacro {
        }
     else
       '{
-          val messageExpr = Resources.didNotCompile(${ code.toExpr })
+          val messageExpr = Resources.didNotCompile($code)
 
           Fact.Yes(
             messageExpr,
@@ -114,22 +114,22 @@ object CompileMacro {
   }
 
   // parse and type check a code snippet, generate code to throw TestFailedException when either parse or type check fails.
-  def assertCompilesImpl(code: String, pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] = {
+  def assertCompilesImpl(code: Expr[String], typeChecked: Boolean, pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Assertion] = {
     import qctx.tasty._
 
-    if (typing.typeChecks(code)) '{ Succeeded }
+    if (typeChecked) '{ Succeeded }
     else '{
-      val messageExpr = Resources.expectedNoErrorButGotTypeError("unknown", ${ code.toExpr })
+      val messageExpr = Resources.expectedNoErrorButGotTypeError("unknown", $code)
       throw new TestFailedException((_: StackDepthException) => Some(messageExpr), None, $pos)
     }
   }
 
-  def expectCompilesImpl(code: String, prettifier: Expr[Prettifier], pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Fact] = {
+  def expectCompilesImpl(code: Expr[String], typeChecked: Boolean, prettifier: Expr[Prettifier], pos: Expr[source.Position])(implicit qctx: QuoteContext): Expr[Fact] = {
     import qctx.tasty._
 
-    if (typing.typeChecks(code))
+    if (typeChecked)
       '{
-          val messageExpr = Resources.compiledSuccessfully(${ code.toExpr })
+          val messageExpr = Resources.compiledSuccessfully($code)
           Fact.Yes(
             messageExpr,
             messageExpr,
@@ -143,7 +143,7 @@ object CompileMacro {
        }
     else
       '{
-          val messageExpr = Resources.expectedNoErrorButGotTypeError("", ${ code.toExpr })
+          val messageExpr = Resources.expectedNoErrorButGotTypeError("", $code)
 
           Fact.No(
             messageExpr,

scalatest.dotty/src/main/scala/org/scalatest/expectations/Expectations.scala

@@ -21,6 +21,7 @@ import Fact._
 import scala.concurrent.ExecutionContext
 import scala.concurrent.Future
 import scala.reflect.ClassTag
+import scala.compiletime.testing.typeChecks
 
 private[scalatest] trait Expectations {
 
@@ -111,13 +112,13 @@ private[scalatest] trait Expectations {
     ${ ExpectationsMacro.expect('{expression})('{prettifier}, '{pos}) }
 
   inline def expectDoesNotCompile(inline code: String)(implicit prettifier: Prettifier, pos: source.Position): Fact =
-    ${ CompileMacro.expectDoesNotCompileImpl(code, 'prettifier, 'pos) }
+    ${ CompileMacro.expectDoesNotCompileImpl('code, typeChecks(code), 'prettifier, 'pos) }
 
   inline def expectCompiles(inline code: String)(implicit prettifier: Prettifier, pos: source.Position): Fact =
-    ${ CompileMacro.expectCompilesImpl(code, 'prettifier, 'pos) }
+    ${ CompileMacro.expectCompilesImpl('code, typeChecks(code), 'prettifier, 'pos) }
 
   inline def expectTypeError(inline code: String)(implicit prettifier: Prettifier, pos: source.Position): Fact =
-    ${ CompileMacro.expectTypeErrorImpl(code, 'prettifier, 'pos) }
+    ${ CompileMacro.expectTypeErrorImpl('code, typeChecks(code), 'prettifier, 'pos) }
 
   import scala.language.implicitConversions