Disallow macro expansion in compilation depending on BE files, add tests

Also includes some minor fixes to shown errors and to the test
framework.

Author: jchyb

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

@@ -714,7 +714,7 @@ object Denotations {
         || ctx.settings.YtestPickler.value // mixing test pickler with debug printing can travel back in time
         || ctx.mode.is(Mode.Printing)  // no use to be picky when printing error messages
         || symbol.isOneOf(ValidForeverFlags)
-        || ctx.isBestEffort, 
+        || ctx.isBestEffort || ctx.usesBestEffortTasty,
         s"denotation $this invalid in run ${ctx.runId}. ValidFor: $validFor")
       var d: SingleDenotation = this
       while ({

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -62,8 +62,9 @@ class TreePickler(pickler: TastyPickler) {
     fillRef(lengthAddr, currentAddr, relative = true)
   }
 
-  /* There are certain expectations with code naturally being able to reach typer vs 
-   * one that uses best-effort-compilation. 
+  /* There are certain expectations with code naturally being able to reach typer
+   * as opposed to one that uses best-effort-compilation. For betasty files, we try
+   * to avoid calling any assertions which can be unfullfilled.
    */
   private inline def assertForBestEffort(assertion: Boolean)(using ctx: Context) =
     !ctx.isBestEffort || assertion
@@ -302,7 +303,7 @@ class TreePickler(pickler: TastyPickler) {
       pickleType(tpe.ref)
     case tpe: ErrorType if ctx.isBestEffort =>
       pickleError()
-    case tree if ctx.isBestEffort => 
+    case _ if ctx.isBestEffort =>
       pickleError()
   }
 

compiler/src/dotty/tools/dotc/inlines/Inliner.scala

@@ -835,7 +835,7 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
       super.typedSplice(tree, pt) match
-        case tree1 @ Splice(expr) if level == 0 && !hasInliningErrors =>
+        case tree1 @ Splice(expr) if level == 0 && !hasInliningErrors && !ctx.usesBestEffortTasty =>
           val expanded = expandMacro(expr, tree1.srcPos)
           transform.TreeChecker.checkMacroGeneratedTree(tree1, expanded)
           typedExpr(expanded) // Inline calls and constant fold code generated by the macro

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -4214,6 +4214,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
      *  tree that went unreported. A scenario where this happens is i1802.scala.
      */
     def ensureReported(tp: Type) = tp match {
+      case err: PreviousErrorType if ctx.usesBestEffortTasty => // do nothing if error was already reported in previous compilation
       case err: ErrorType if !ctx.reporter.errorsReported => report.error(err.msg, tree.srcPos)
       case _ =>
     }

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

@@ -21,8 +21,8 @@ class BestEffortCompilationTests {
   @Test def negTestFromBestEffortTasty: Unit = {
     // Can be reproduced with
     // > sbt
-    // > scalac --Ybest-effort-dir best-effort-dir <source>
-    // > scalac --from-tasty -Ywith-best-effort-tasty best-effort-dir/<tasty>
+    // > scalac --Ybest-effort <source>
+    // > scalac --from-tasty -Ywith-best-effort-tasty META_INF/best-effort/<tasty>
 
     implicit val testGroup: TestGroup = TestGroup("negTestFromBestEffortTasty")
     compileBestEffortTastyInDir(s"tests${JFile.separator}neg", bestEffortBaselineOptions,
@@ -34,7 +34,7 @@ class BestEffortCompilationTests {
   // Tests an actual use case of this compilation mode, where symbol definitions of the downstream
   // projects depend on the best effort tasty files generated with the Best Effort dir option
   @Test def bestEffortIntergrationTest: Unit = {
-    implicit val testGroup: TestGroup = TestGroup("BestEffortIntegrationTest")
+    implicit val testGroup: TestGroup = TestGroup("bestEffortIntegrationTests")
     compileBestEffortIntegration(s"tests${JFile.separator}best-effort", bestEffortBaselineOptions)
       .noCrashWithCompilingDependencies()
   }

tests/best-effort/broken-macro-executed-in-dependency/err/ExecutedMacro.scala

@@ -0,0 +1,2 @@
+object ExecutedMacro:
+  val failingMacro = FailingTransparent.execute()

tests/best-effort/broken-macro-executed-in-dependency/err/FailingTransparentInline.scala

@@ -0,0 +1,11 @@
+object FailingTransparentInline:
+  sealed trait Foo
+  case class FooA() extends Foo
+  case class FooB() extends Foo
+
+  transparent inline def execute(): Foo = ${ executeImpl() }
+  def executeImpl(using Quotes)() = {
+    val a = 0
+    a.asInstanceOf[String]
+    FooB()
+  }

tests/best-effort/broken-macro-executed-in-dependency/main/Main.scala

@@ -0,0 +1,2 @@
+object Main:
+  ExecutedMacro.failingMacro

tests/best-effort/broken-macro-executed-in-dependent/err/BrokenMacros.scala

@@ -0,0 +1,13 @@
+import scala.quoted._
+object BrokenMacros:
+  transparent inline def macro1() = ${macroImpl()}
+  def macroImpl(using Quotes)(): Expr[String] =
+    val a: Int = "str" // source of the error
+    '{a}
+
+  sealed trait Foo
+  case class FooA() extends Foo
+  case class FooB()
+  transparent inline def macro2(): Foo = ${macro2Impl()}
+  def macro2Impl(using Quotes)(): Expr[Foo] =
+    '{FooB()}

tests/best-effort/broken-macro-executed-in-dependent/main/Main.scala

@@ -0,0 +1,3 @@
+object Main
+  val a = BrokenMacros.macro1()
+  val b = BrokenMacros.macro2()