From 4bcd23b0ba8ae7cfa79b8a12bd462246abaa0857 Mon Sep 17 00:00:00 2001 From: Guillaume Martres Date: Sat, 5 Feb 2022 18:52:25 +0100 Subject: [PATCH] Revert "Show inlined positions with source code" This temporarily reverts commit e523c8d455a0ec13c12551141b80eaed4426f844 to fix the CI, see #14406. --- .../dotc/reporting/MessageRendering.scala | 183 +++++------------- .../dotty/tools/dotc/transform/Splicer.scala | 2 +- .../src/dotty/tools/dotc/typer/Inliner.scala | 2 +- compiler/test-resources/repl/i9227 | 1 + tests/neg-macros/delegate-match-1.check | 1 + tests/neg-macros/delegate-match-2.check | 1 + tests/neg-macros/delegate-match-3.check | 1 + tests/neg-macros/i11386.check | 18 +- tests/neg-macros/i13991.check | 16 -- tests/neg-macros/i13991/Macro_1.scala | 10 - tests/neg-macros/i13991/Test_2.scala | 6 - tests/neg-macros/i6432.check | 3 + tests/neg-macros/i6432b.check | 3 + tests/neg-macros/i6976.check | 8 +- tests/neg-macros/i9014.check | 1 + tests/neg-macros/ill-abort.check | 8 +- .../neg-macros/macro-class-not-found-1.check | 8 +- .../neg-macros/macro-class-not-found-2.check | 8 +- .../neg-macros/macros-in-same-project-6.check | 1 + tests/neg-scalajs/js-enums.check | 6 +- tests/neg/cannot-reduce-inline-match.check | 10 +- tests/neg/i11225.check | 8 +- tests/neg/i13044.check | 166 +++------------- tests/neg/i13570.check | 11 +- tests/neg/i13991.check | 15 -- tests/neg/i13991.scala | 11 -- tests/neg/inline-error-pos.check | 9 +- tests/neg/summonInline.check | 16 +- 28 files changed, 111 insertions(+), 422 deletions(-) delete mode 100644 tests/neg-macros/i13991.check delete mode 100644 tests/neg-macros/i13991/Macro_1.scala delete mode 100644 tests/neg-macros/i13991/Test_2.scala delete mode 100644 tests/neg/i13991.check delete mode 100644 tests/neg/i13991.scala mode change 100644 => 100755 tests/neg/summonInline.check diff --git a/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala b/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala index 1cc98cf75898..f5b566f3ba60 100644 --- a/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala +++ b/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala @@ -16,8 +16,6 @@ import scala.annotation.switch import scala.collection.mutable trait MessageRendering { - import Highlight.* - import Offsets.* /** Remove ANSI coloring from `str`, useful for getting real length of * strings @@ -27,9 +25,15 @@ trait MessageRendering { def stripColor(str: String): String = str.replaceAll("\u001b\\[.*?m", "") - /** List of all the inline calls that surround the position */ - def inlinePosStack(pos: SourcePosition): List[SourcePosition] = - if pos.outer != null && pos.outer.exists then pos :: inlinePosStack(pos.outer) + /** When inlining a method call, if there's an error we'd like to get the + * outer context and the `pos` at which the call was inlined. + * + * @return a list of strings with inline locations + */ + def outer(pos: SourcePosition, prefix: String)(using Context): List[String] = + if (pos.outer.exists) + i"$prefix| This location contains code that was inlined from $pos" :: + outer(pos.outer, prefix) else Nil /** Get the sourcelines before and after the position, as well as the offset @@ -37,15 +41,15 @@ trait MessageRendering { * * @return (lines before error, lines after error, line numbers offset) */ - private def sourceLines(pos: SourcePosition)(using Context, Level, Offset): (List[String], List[String], Int) = { + def sourceLines(pos: SourcePosition, diagnosticLevel: String)(using Context): (List[String], List[String], Int) = { assert(pos.exists && pos.source.file.exists) var maxLen = Int.MinValue def render(offsetAndLine: (Int, String)): String = { - val (offset1, line) = offsetAndLine - val lineNbr = (pos.source.offsetToLine(offset1) + 1).toString - val prefix = String.format(s"%${offset - 2}s |", lineNbr) + val (offset, line) = offsetAndLine + val lineNbr = pos.source.offsetToLine(offset) + val prefix = s"${lineNbr + 1} |" maxLen = math.max(maxLen, prefix.length) - val lnum = hl(" " * math.max(0, maxLen - prefix.length - 1) + prefix) + val lnum = hl(diagnosticLevel)(" " * math.max(0, maxLen - prefix.length) + prefix) lnum + line.stripLineEnd } @@ -73,75 +77,23 @@ trait MessageRendering { ) } - /** Generate box containing the report title - * - * ``` - * -- Error: source.scala --------------------- - * ``` - */ - private def boxTitle(title: String)(using Context, Level, Offset): String = - val pageWidth = ctx.settings.pageWidth.value - val line = "-" * (pageWidth - title.length - 4) - hl(s"-- $title $line") - - /** The position markers aligned under the error - * - * ``` - * | ^^^^^ - * ``` - */ - private def positionMarker(pos: SourcePosition)(using Context, Level, Offset): String = { + /** The column markers aligned under the error */ + def columnMarker(pos: SourcePosition, offset: Int, diagnosticLevel: String)(using Context): String = { + val prefix = " " * (offset - 1) val padding = pos.startColumnPadding - val carets = + val carets = hl(diagnosticLevel) { if (pos.startLine == pos.endLine) "^" * math.max(1, pos.endColumn - pos.startColumn) else "^" - hl(s"$offsetBox$padding$carets") + } + s"$prefix|$padding$carets" } - /** The horizontal line with the given offset - * - * ``` - * | - * ``` - */ - private def offsetBox(using Context, Level, Offset): String = - val prefix = " " * (offset - 1) - hl(s"$prefix|") - - /** The end of a box section - * - * ``` - * |--------------- - * ``` - * Or if there `soft` is true, - * ``` - * |··············· - * ``` - */ - private def newBox(soft: Boolean = false)(using Context, Level, Offset): String = - val pageWidth = ctx.settings.pageWidth.value - val prefix = " " * (offset - 1) - val line = (if soft then "·" else "-") * (pageWidth - offset) - hl(s"$prefix|$line") - - /** The end of a box section - * - * ``` - * ·---------------- - * ``` - */ - private def endBox(using Context, Level, Offset): String = - val pageWidth = ctx.settings.pageWidth.value - val prefix = " " * (offset - 1) - val line = "-" * (pageWidth - offset) - hl(s"${prefix}·$line") - /** The error message (`msg`) aligned under `pos` * * @return aligned error message */ - private def errorMsg(pos: SourcePosition, msg: String)(using Context, Level, Offset): String = { + def errorMsg(pos: SourcePosition, msg: String, offset: Int)(using Context): String = { val padding = msg.linesIterator.foldLeft(pos.startColumnPadding) { (pad, line) => val lineLength = stripColor(line).length val maxPad = math.max(0, ctx.settings.pageWidth.value - offset - lineLength) - offset @@ -151,12 +103,12 @@ trait MessageRendering { } msg.linesIterator - .map { line => offsetBox + (if line.isEmpty then "" else padding + line) } + .map { line => " " * (offset - 1) + "|" + (if line.isEmpty then "" else padding + line) } .mkString(EOL) } /** The source file path, line and column numbers from the given SourcePosition */ - protected def posFileStr(pos: SourcePosition): String = + def posFileStr(pos: SourcePosition): String = val path = pos.source.file.path if pos.exists then s"$path:${pos.line + 1}:${pos.column}" else path @@ -164,22 +116,22 @@ trait MessageRendering { * * @return separator containing error location and kind */ - private def posStr(pos: SourcePosition, message: Message, diagnosticString: String)(using Context, Level, Offset): String = - if (pos.source != NoSourcePosition.source) hl({ - val realPos = pos.nonInlined - val fileAndPos = posFileStr(realPos) + def posStr(pos: SourcePosition, diagnosticLevel: String, message: Message)(using Context): String = + if (pos.source != NoSourcePosition.source) hl(diagnosticLevel)({ + val fileAndPos = posFileStr(pos.nonInlined) + val file = if fileAndPos.isEmpty || fileAndPos.endsWith(" ") then fileAndPos else s"$fileAndPos " val errId = if (message.errorId ne ErrorMessageID.NoExplanationID) { val errorNumber = message.errorId.errorNumber s"[E${"0" * (3 - errorNumber.toString.length) + errorNumber}] " } else "" val kind = - if (message.kind == "") diagnosticString - else s"${message.kind} $diagnosticString" - val title = - if fileAndPos.isEmpty then s"$errId$kind:" // this happens in dotty.tools.repl.ScriptedTests // TODO add name of source or remove `:` (and update test files) - else s"$errId$kind: $fileAndPos" - boxTitle(title) + if (message.kind == "") diagnosticLevel + else s"${message.kind} $diagnosticLevel" + val prefix = s"-- ${errId}${kind}: $file" + + prefix + + ("-" * math.max(ctx.settings.pageWidth.value - stripColor(prefix).length, 0)) }) else "" /** Explanation rendered under "Explanation" header */ @@ -194,7 +146,7 @@ trait MessageRendering { sb.toString } - private def appendFilterHelp(dia: Diagnostic, sb: mutable.StringBuilder): Unit = + def appendFilterHelp(dia: Diagnostic, sb: mutable.StringBuilder): Unit = import dia._ val hasId = msg.errorId.errorNumber >= 0 val category = dia match { @@ -214,34 +166,17 @@ trait MessageRendering { /** The whole message rendered from `msg` */ def messageAndPos(dia: Diagnostic)(using Context): String = { import dia._ - val pos1 = pos.nonInlined - val inlineStack = inlinePosStack(pos).filter(_ != pos1) - val maxLineNumber = - if pos.exists then (pos1 :: inlineStack).map(_.endLine).max + 1 - else 0 - given Level = Level(level) - given Offset = Offset(maxLineNumber.toString.length + 2) + val levelString = diagnosticLevel(dia) val sb = mutable.StringBuilder() - val posString = posStr(pos, msg, diagnosticLevel(dia)) + val posString = posStr(pos, levelString, msg) if (posString.nonEmpty) sb.append(posString).append(EOL) if (pos.exists) { val pos1 = pos.nonInlined if (pos1.exists && pos1.source.file.exists) { - val (srcBefore, srcAfter, offset) = sourceLines(pos1) - val marker = positionMarker(pos1) - val err = errorMsg(pos1, msg.message) - sb.append((srcBefore ::: marker :: err :: srcAfter).mkString(EOL)) - - if inlineStack.nonEmpty then - sb.append(EOL).append(newBox()) - sb.append(EOL).append(offsetBox).append(i"Inline stack trace") - for inlinedPos <- inlineStack if inlinedPos != pos1 do - val (srcBefore, srcAfter, offset) = sourceLines(inlinedPos) - val marker = positionMarker(inlinedPos) - sb.append(EOL).append(newBox(soft = true)) - sb.append(EOL).append(offsetBox).append(i"This location contains code that was inlined from $pos") - sb.append(EOL).append((srcBefore ::: marker :: srcAfter).mkString(EOL)) - sb.append(EOL).append(endBox) + val (srcBefore, srcAfter, offset) = sourceLines(pos1, levelString) + val marker = columnMarker(pos1, offset, levelString) + val err = errorMsg(pos1, msg.message, offset) + sb.append((srcBefore ::: marker :: err :: outer(pos, " " * (offset - 1)) ::: srcAfter).mkString(EOL)) } else sb.append(msg.message) } @@ -251,13 +186,15 @@ trait MessageRendering { sb.toString } - private def hl(str: String)(using Context, Level): String = - summon[Level].value match - case interfaces.Diagnostic.ERROR => Red(str).show - case interfaces.Diagnostic.WARNING => Yellow(str).show - case interfaces.Diagnostic.INFO => Blue(str).show + def hl(diagnosticLevel: String)(str: String)(using Context): String = diagnosticLevel match { + case "Info" => Blue(str).show + case "Error" => Red(str).show + case _ => + assert(diagnosticLevel.contains("Warning")) + Yellow(str).show + } - private def diagnosticLevel(dia: Diagnostic): String = + def diagnosticLevel(dia: Diagnostic): String = dia match { case dia: FeatureWarning => "Feature Warning" case dia: DeprecationWarning => "Deprecation Warning" @@ -268,28 +205,4 @@ trait MessageRendering { case interfaces.Diagnostic.WARNING => "Warning" case interfaces.Diagnostic.INFO => "Info" } - -} - -private object Highlight { - opaque type Level = Int - extension (level: Level) def value: Int = level - object Level: - def apply(level: Int): Level = level -} - -/** Size of the left offset added by the box - * - * ``` - * -- Error: ... ------------ - * 4 | foo - * | ^^^ - * ^^^ // size of this offset - * ``` - */ -private object Offsets { - opaque type Offset = Int - def offset(using o: Offset): Int = o - object Offset: - def apply(level: Int): Offset = level } diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala index dcd5b8d8c4b5..49b6f5564620 100644 --- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala +++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala @@ -49,7 +49,7 @@ object Splicer { val oldContextClassLoader = Thread.currentThread().getContextClassLoader Thread.currentThread().setContextClassLoader(classLoader) try { - val interpreter = new Interpreter(splicePos, classLoader) + val interpreter = new Interpreter(spliceExpansionPos, classLoader) // Some parts of the macro are evaluated during the unpickling performed in quotedExprToTree val interpretedExpr = interpreter.interpret[Quotes => scala.quoted.Expr[Any]](tree) diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala index c99ccbd24428..722e3abfec85 100644 --- a/compiler/src/dotty/tools/dotc/typer/Inliner.scala +++ b/compiler/src/dotty/tools/dotc/typer/Inliner.scala @@ -853,7 +853,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) { evidence.tpe match case fail: Implicits.SearchFailureType => val msg = evTyper.missingArgMsg(evidence, tpt.tpe, "") - errorTree(call, em"$msg") + errorTree(tpt, em"$msg") case _ => evidence return searchImplicit(callTypeArgs.head) diff --git a/compiler/test-resources/repl/i9227 b/compiler/test-resources/repl/i9227 index 40f9248898a2..45d1731dae39 100644 --- a/compiler/test-resources/repl/i9227 +++ b/compiler/test-resources/repl/i9227 @@ -3,4 +3,5 @@ scala> import scala.quoted._; inline def myMacro[T]: Unit = ${ myMacroImpl[T] }; 1 | import scala.quoted._; inline def myMacro[T]: Unit = ${ myMacroImpl[T] }; def myMacroImpl[T](using Quotes): Expr[Unit] = '{}; println(myMacro[Int]) | ^^^^^^^^^^^^ | Cannot call macro method myMacroImpl defined in the same source file + | This location contains code that was inlined from rs$line$1:1 1 error found diff --git a/tests/neg-macros/delegate-match-1.check b/tests/neg-macros/delegate-match-1.check index 93b20beba183..6d88d021416f 100644 --- a/tests/neg-macros/delegate-match-1.check +++ b/tests/neg-macros/delegate-match-1.check @@ -4,3 +4,4 @@ | ^ | AmbiguousImplicits | both value a1 in class Test1 and value a2 in class Test1 match type A + | This location contains code that was inlined from Test_2.scala:6 diff --git a/tests/neg-macros/delegate-match-2.check b/tests/neg-macros/delegate-match-2.check index e26742452b5b..112e5ee00474 100644 --- a/tests/neg-macros/delegate-match-2.check +++ b/tests/neg-macros/delegate-match-2.check @@ -4,3 +4,4 @@ | ^ | DivergingImplicit | method a1 in class Test produces a diverging implicit search when trying to match type A + | This location contains code that was inlined from Test_2.scala:5 diff --git a/tests/neg-macros/delegate-match-3.check b/tests/neg-macros/delegate-match-3.check index 2b6fda278fda..278aa92a4117 100644 --- a/tests/neg-macros/delegate-match-3.check +++ b/tests/neg-macros/delegate-match-3.check @@ -4,3 +4,4 @@ | ^ | NoMatchingImplicits | no implicit values were found that match type A + | This location contains code that was inlined from Test_2.scala:3 diff --git a/tests/neg-macros/i11386.check b/tests/neg-macros/i11386.check index 1cce199159a5..0377ca6389db 100644 --- a/tests/neg-macros/i11386.check +++ b/tests/neg-macros/i11386.check @@ -3,21 +3,11 @@ 6 | dummy(0) // error | ^ | test - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from Test_2.scala:6 -7 | notNull(i) - | ^^^^^^^^^^ - ·--------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from Test_2.scala:6 + | This location contains code that was inlined from Macro_1.scala:7 -- Error: tests/neg-macros/i11386/Test_2.scala:8:20 -------------------------------------------------------------------- 8 | dummy(int2String(0)) // error | ^^^^^^^^^^^^^ | test - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from Test_2.scala:8 -7 | notNull(i) - | ^^^^^^^^^^ - ·--------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from Test_2.scala:8 + | This location contains code that was inlined from Macro_1.scala:7 diff --git a/tests/neg-macros/i13991.check b/tests/neg-macros/i13991.check deleted file mode 100644 index 15f45af227e5..000000000000 --- a/tests/neg-macros/i13991.check +++ /dev/null @@ -1,16 +0,0 @@ - --- Error: tests/neg-macros/i13991/Test_2.scala:6:5 --------------------------------------------------------------------- -6 | v2 // error - | ^^ - | Error - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from Test_2.scala:3 -3 | inline def v2 = InlineMac.sample("foo") - | ^^^^^ - |····················································································································· - |This location contains code that was inlined from Test_2.scala:3 -3 | inline def v2 = InlineMac.sample("foo") - | ^^^^^^^^^^^^^^^^^^^^^^^ - ·--------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg-macros/i13991/Macro_1.scala b/tests/neg-macros/i13991/Macro_1.scala deleted file mode 100644 index 76cfa93cdde5..000000000000 --- a/tests/neg-macros/i13991/Macro_1.scala +++ /dev/null @@ -1,10 +0,0 @@ -import scala.quoted.* - -object InlineMac: - - inline def sample(inline expr: String): Int = - ${ sampleImpl('expr) } - - def sampleImpl(expr: Expr[String])(using Quotes): Expr[Int] = - import quotes.reflect.* - report.errorAndAbort("Error", expr) diff --git a/tests/neg-macros/i13991/Test_2.scala b/tests/neg-macros/i13991/Test_2.scala deleted file mode 100644 index 572ad324b129..000000000000 --- a/tests/neg-macros/i13991/Test_2.scala +++ /dev/null @@ -1,6 +0,0 @@ -object Main: - def main(args: Array[String]): Unit = - inline def v2 = InlineMac.sample("foo") - inline def v1 = v2 - - v2 // error diff --git a/tests/neg-macros/i6432.check b/tests/neg-macros/i6432.check index 2ea6f3ba0300..0e01f99be404 100644 --- a/tests/neg-macros/i6432.check +++ b/tests/neg-macros/i6432.check @@ -3,11 +3,14 @@ 4 | foo"abc${"123"}xyz${"456"}fgh" // error // error // error | ^^^ | abc + | This location contains code that was inlined from Test_2.scala:4 -- Error: tests/neg-macros/i6432/Test_2.scala:4:17 --------------------------------------------------------------------- 4 | foo"abc${"123"}xyz${"456"}fgh" // error // error // error | ^^^ | xyz + | This location contains code that was inlined from Test_2.scala:4 -- Error: tests/neg-macros/i6432/Test_2.scala:4:28 --------------------------------------------------------------------- 4 | foo"abc${"123"}xyz${"456"}fgh" // error // error // error | ^^^ | fgh + | This location contains code that was inlined from Test_2.scala:4 diff --git a/tests/neg-macros/i6432b.check b/tests/neg-macros/i6432b.check index 395d089c92e9..4dd1be84fa3c 100644 --- a/tests/neg-macros/i6432b.check +++ b/tests/neg-macros/i6432b.check @@ -3,11 +3,14 @@ 4 | foo"""abc${"123"}xyz${"456"}fgh""" // error // error // error | ^^^ | abc + | This location contains code that was inlined from Test_2.scala:4 -- Error: tests/neg-macros/i6432b/Test_2.scala:4:19 -------------------------------------------------------------------- 4 | foo"""abc${"123"}xyz${"456"}fgh""" // error // error // error | ^^^ | xyz + | This location contains code that was inlined from Test_2.scala:4 -- Error: tests/neg-macros/i6432b/Test_2.scala:4:30 -------------------------------------------------------------------- 4 | foo"""abc${"123"}xyz${"456"}fgh""" // error // error // error | ^^^ | fgh + | This location contains code that was inlined from Test_2.scala:4 diff --git a/tests/neg-macros/i6976.check b/tests/neg-macros/i6976.check index b67f05960a79..2057e55550b4 100644 --- a/tests/neg-macros/i6976.check +++ b/tests/neg-macros/i6976.check @@ -6,10 +6,4 @@ | scala.MatchError: Inlined(EmptyTree,List(),Literal(Constant(2))) (of class dotty.tools.dotc.ast.Trees$Inlined) | at playground.macros$.mcrImpl(Macro_1.scala:10) | - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from Macro_1.scala:6 -6 | inline def mcr(x: => Any) = ${mcrImpl('x)} - | ^^^^^^^^^^^^^^ - ·--------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from Test_2.scala:5 diff --git a/tests/neg-macros/i9014.check b/tests/neg-macros/i9014.check index c0d08a42ef2a..509eac067fc8 100644 --- a/tests/neg-macros/i9014.check +++ b/tests/neg-macros/i9014.check @@ -3,3 +3,4 @@ 1 |val tests = summon[Bar] // error | ^ | Failed to expand! + | This location contains code that was inlined from Test_2.scala:1 diff --git a/tests/neg-macros/ill-abort.check b/tests/neg-macros/ill-abort.check index 2aa9d3396e53..25d7654b1b69 100644 --- a/tests/neg-macros/ill-abort.check +++ b/tests/neg-macros/ill-abort.check @@ -3,10 +3,4 @@ 1 |def test = fail() // error | ^^^^^^ |Macro expansion was aborted by the macro without any errors reported. Macros should issue errors to end-users to facilitate debugging when aborting a macro expansion. - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from quoted_1.scala:3 -3 |inline def fail(): Unit = ${ impl } - | ^^^^^^^^^ - ·--------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from quoted_1.scala:3 diff --git a/tests/neg-macros/macro-class-not-found-1.check b/tests/neg-macros/macro-class-not-found-1.check index 08ba5b99f0b8..445523c6ade2 100644 --- a/tests/neg-macros/macro-class-not-found-1.check +++ b/tests/neg-macros/macro-class-not-found-1.check @@ -5,10 +5,4 @@ | java.lang.NoClassDefFoundError | at Foo$.aMacroImplementation(Foo.scala:8) | - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from Foo.scala:5 -5 | inline def myMacro(): Unit = ${ aMacroImplementation } - | ^^^^^^^^^^^^^^^^^^^^^^^^^ - ·--------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from Bar.scala:4 diff --git a/tests/neg-macros/macro-class-not-found-2.check b/tests/neg-macros/macro-class-not-found-2.check index d4ed8f222ba0..3cb7506e6bb2 100644 --- a/tests/neg-macros/macro-class-not-found-2.check +++ b/tests/neg-macros/macro-class-not-found-2.check @@ -5,10 +5,4 @@ | java.lang.NoClassDefFoundError: this.is.not.a.Class | at Foo$.aMacroImplementation(Foo.scala:8) | - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from Foo.scala:5 -5 | inline def myMacro(): Unit = ${ aMacroImplementation } - | ^^^^^^^^^^^^^^^^^^^^^^^^^ - ·--------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from Bar.scala:4 diff --git a/tests/neg-macros/macros-in-same-project-6.check b/tests/neg-macros/macros-in-same-project-6.check index 17f696508259..485f5062db92 100644 --- a/tests/neg-macros/macros-in-same-project-6.check +++ b/tests/neg-macros/macros-in-same-project-6.check @@ -2,3 +2,4 @@ 4 | Foo.myMacro() // error | ^^^^^^^^^^^^^ | some error + | This location contains code that was inlined from Bar.scala:4 diff --git a/tests/neg-scalajs/js-enums.check b/tests/neg-scalajs/js-enums.check index e54b2a5af2da..eb358f16e57a 100644 --- a/tests/neg-scalajs/js-enums.check +++ b/tests/neg-scalajs/js-enums.check @@ -4,9 +4,9 @@ |MyEnum extends scala.reflect.Enum which does not extend js.Any. 5 | case Foo -- Error: tests/neg-scalajs/js-enums.scala:9:5 ------------------------------------------------------------------------- - 7 |@js.native - 8 |@JSGlobal - 9 |enum MyEnumNative extends js.Object: // error +7 |@js.native +8 |@JSGlobal +9 |enum MyEnumNative extends js.Object: // error |^ |MyEnumNative extends scala.reflect.Enum which does not extend js.Any. 10 | case Bar diff --git a/tests/neg/cannot-reduce-inline-match.check b/tests/neg/cannot-reduce-inline-match.check index e35066949333..ceca40a74cbd 100644 --- a/tests/neg/cannot-reduce-inline-match.check +++ b/tests/neg/cannot-reduce-inline-match.check @@ -4,12 +4,4 @@ | cannot reduce inline match with | scrutinee: "f" : ("f" : String) | patterns : case _:Int - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from cannot-reduce-inline-match.scala:3 -3 | inline x match { - | ^ -4 | case _: Int => -5 | } - ·--------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from cannot-reduce-inline-match.scala:3 diff --git a/tests/neg/i11225.check b/tests/neg/i11225.check index 0aa5f720e24b..60805a27b22d 100644 --- a/tests/neg/i11225.check +++ b/tests/neg/i11225.check @@ -42,10 +42,4 @@ 30 | var x7: Int = uni // error | ^^^ | `uninitialized` can only be used as the right hand side of a mutable field definition - |-------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |···················································································································· - |This location contains code that was inlined from i11225.scala:25 -25 | transparent inline def uni = uninitialized - | ^^^^^^^^^^^^^ - ·-------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from i11225.scala:25 diff --git a/tests/neg/i13044.check b/tests/neg/i13044.check index b3e278792148..87b8a1fe9ae2 100644 --- a/tests/neg/i13044.check +++ b/tests/neg/i13044.check @@ -4,143 +4,41 @@ | given instance gen is declared as `inline`, but was not inlined | | Try increasing `-Xmax-inlines` above 32 - |-------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -17 | val builder = summonInline[Schema[t]].asInstanceOf[Schema[Any]] - | ^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -17 | val builder = summonInline[Schema[t]].asInstanceOf[Schema[Any]] - | ^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -17 | val builder = summonInline[Schema[t]].asInstanceOf[Schema[Any]] - | ^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -17 | val builder = summonInline[Schema[t]].asInstanceOf[Schema[Any]] - | ^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -17 | val builder = summonInline[Schema[t]].asInstanceOf[Schema[Any]] - | ^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -18 | builder :: recurse[ts] - | ^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:17 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - ·-------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from i13044.scala:17 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 + | This location contains code that was inlined from i13044.scala:17 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 + | This location contains code that was inlined from i13044.scala:17 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 + | This location contains code that was inlined from i13044.scala:17 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 + | This location contains code that was inlined from i13044.scala:17 + | This location contains code that was inlined from i13044.scala:18 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 -- Error: tests/neg/i13044.scala:50:40 --------------------------------------------------------------------------------- 50 | implicit def typeSchema: Schema[A] = Schema.gen // error // error | ^^^^^^^^^^ | method recurse is declared as `inline`, but was not inlined | | Try increasing `-Xmax-inlines` above 32 - |-------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -18 | builder :: recurse[ts] - | ^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -17 | val builder = summonInline[Schema[t]].asInstanceOf[Schema[Any]] - | ^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -17 | val builder = summonInline[Schema[t]].asInstanceOf[Schema[Any]] - | ^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -17 | val builder = summonInline[Schema[t]].asInstanceOf[Schema[Any]] - | ^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -17 | val builder = summonInline[Schema[t]].asInstanceOf[Schema[Any]] - | ^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -18 | builder :: recurse[ts] - | ^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -31 | lazy val fields = recurse[m.MirroredElemTypes] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13044.scala:18 -37 | inline given gen[A]: Schema[A] = derived - | ^^^^^^^ - ·-------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from i13044.scala:18 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 + | This location contains code that was inlined from i13044.scala:17 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 + | This location contains code that was inlined from i13044.scala:17 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 + | This location contains code that was inlined from i13044.scala:17 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 + | This location contains code that was inlined from i13044.scala:17 + | This location contains code that was inlined from i13044.scala:18 + | This location contains code that was inlined from i13044.scala:31 + | This location contains code that was inlined from i13044.scala:37 diff --git a/tests/neg/i13570.check b/tests/neg/i13570.check index cf1649b5f4a6..90e29476b7b1 100644 --- a/tests/neg/i13570.check +++ b/tests/neg/i13570.check @@ -6,13 +6,4 @@ | patterns : case s @ _:Seq[Int] if s.isEmpty | case s @ _:Seq[Int] | case _ - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from i13570.scala:3 -3 | inline seq match - | ^ -4 | case s: Seq[Int] if s.isEmpty => println("seq is empty") -5 | case s: Seq[Int] => println("seq is not empty") -6 | case _ => println("somthing hinky happened") - ·--------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from i13570.scala:3 diff --git a/tests/neg/i13991.check b/tests/neg/i13991.check deleted file mode 100644 index fd092b759c2b..000000000000 --- a/tests/neg/i13991.check +++ /dev/null @@ -1,15 +0,0 @@ --- Error: tests/neg/i13991.scala:5:7 ----------------------------------------------------------------------------------- - 5 | first[String] // error // before line 10 to test alignment of the error message `|` - | ^^^^^^^^^^^^^ - | no implicit argument of type Foo[String] was found - |-------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |···················································································································· - |This location contains code that was inlined from i13991.scala:8 - 8 | compiletime.summonInline[Foo[A]].foo - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - |···················································································································· - |This location contains code that was inlined from i13991.scala:8 -11 | second[A] + 42 // after line 10 to test alignment of the error message `|` - | ^^^^^^^^^ - ·-------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg/i13991.scala b/tests/neg/i13991.scala deleted file mode 100644 index af15891e82d3..000000000000 --- a/tests/neg/i13991.scala +++ /dev/null @@ -1,11 +0,0 @@ -trait Foo[X]: - def foo: Int - -def foo = - first[String] // error // before line 10 to test alignment of the error message `|` - -inline def second[A]: Int = - compiletime.summonInline[Foo[A]].foo - -inline def first[A]: Int = - second[A] + 42 // after line 10 to test alignment of the error message `|` diff --git a/tests/neg/inline-error-pos.check b/tests/neg/inline-error-pos.check index 1d65175c6c39..121684fe14d6 100644 --- a/tests/neg/inline-error-pos.check +++ b/tests/neg/inline-error-pos.check @@ -4,11 +4,4 @@ | cannot reduce inline match with | scrutinee: 2 : (2 : Int) | patterns : case 1 - |--------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |····················································································································· - |This location contains code that was inlined from inline-error-pos.scala:3 -3 | inline x match - | ^ -4 | case 1 => 9 - ·--------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from inline-error-pos.scala:3 diff --git a/tests/neg/summonInline.check b/tests/neg/summonInline.check old mode 100644 new mode 100755 index db9b6968ee43..d118299d6dc5 --- a/tests/neg/summonInline.check +++ b/tests/neg/summonInline.check @@ -2,21 +2,9 @@ 19 |val missing1 = summonInlineCheck(1) // error | ^^^^^^^^^^^^^^^^^^^^ | Missing One - |-------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |···················································································································· - |This location contains code that was inlined from summonInline.scala:15 -15 | case 1 => summonInline[Missing1] - | ^^^^^^^^^^^^^^^^^^^^^^ - ·-------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from summonInline.scala:15 -- Error: tests/neg/summonInline.scala:20:32 --------------------------------------------------------------------------- 20 |val missing2 = summonInlineCheck(2) // error | ^^^^^^^^^^^^^^^^^^^^ | Missing Two - |-------------------------------------------------------------------------------------------------------------------- - |Inline stack trace - |···················································································································· - |This location contains code that was inlined from summonInline.scala:16 -16 | case 2 => summonInline[Missing2] - | ^^^^^^^^^^^^^^^^^^^^^^ - ·-------------------------------------------------------------------------------------------------------------------- + | This location contains code that was inlined from summonInline.scala:16