++scala> import scala.annotation.nowarn+import scala.annotation.nowarn++scala> scala.#::.unapply(Stream(1))+                 ^+       warning: method unapply in object #:: is deprecated (since 2.13.0): Prefer LazyList instead+                         ^+       warning: value Stream in package scala is deprecated (since 2.13.0): Use LazyList instead of Stream+val res0: Option[(Int, Stream[Int])] = Some((1,Stream()))++scala> scala.#::.unapply(Stream(1)): @nowarn+val res1: Option[(Int, Stream[Int])] @scala.annotation.nowarn = Some((1,Stream()))++scala> (scala.#::.unapply(Stream(1)): @nowarn)+val res2: Option[(Int, Stream[Int])] @scala.annotation.nowarn = Some((1,Stream()))++scala> scala.#::.unapply(Stream(1)): @inline+                 ^+       warning: method unapply in object #:: is deprecated (since 2.13.0): Prefer LazyList instead+                         ^+       warning: value Stream in package scala is deprecated (since 2.13.0): Use LazyList instead of Stream+                                      ^+       warning: type Stream in package scala is deprecated (since 2.13.0): Use LazyList instead of Stream

 trait Scanners extends ScannersCommon {       } else unclosedStringLit()     } -    private def unclosedStringLit(): Unit = syntaxError("unclosed string literal")+    private def unclosedStringLit(seenEscapedQuoteInInterpolation: Boolean = false): Unit = {+      val note =+        if (seenEscapedQuoteInInterpolation) "; note that `\\\"` no longer closes single-quoted interpolated string literals since 2.13.6, you can use a triple-quoted string instead"

 alphaid                ::= upper idrest  ``` -Interpolated string consist of an identifier starting with a letter immediately +An interpolated string consist of an identifier starting with a letter immediately followed by a string literal. There may be no whitespace characters or comments -between the leading identifier and the opening quote ‘”’ of the string. -The string literal in a interpolated string can be standard (single quote) +between the leading identifier and the opening quote `"` of the string.+The string literal in an interpolated string can be standard (single quote) or multi-line (triple quote). -Inside a interpolated string none of the usual escape characters are interpreted -(except for unicode escapes) no matter whether the string literal is normal -(enclosed in single quotes) or multi-line (enclosed in triple quotes). -Instead, there are two new forms of dollar sign escape. +Inside an interpolated string none of the usual escape characters are interpreted+no matter whether the string literal is normal (enclosed in single quotes) or+multi-line (enclosed in triple quotes). Note that the sequence `\"` does not+close a normal string literal (enclosed in single quotes).++There are two new forms of dollar sign escape. 

 alphaid                ::= upper idrest  ``` -Interpolated string consist of an identifier starting with a letter immediately +An interpolated string consist of an identifier starting with a letter immediately

  package scala.tools.nsc.interpreter -import scala.util.Properties.lineSeparator import scala.util.matching.Regex  /** This is for name logic which is independent of the compiler (notice there's no Global.)  *  That includes at least generating, metaquoting, mangling, and unmangling.  */ object Naming {-  def unmangle(str: String): String = {-    val ESC = '\u001b'-    val cleaned = lineRegex.replaceAllIn(str, "")-    // Looking to exclude binary data which hoses the terminal, but-    // let through the subset of it we need, like whitespace and also-    // <ESC> for ansi codes.-    val binaryChars = cleaned count (ch => ch < 32 && !ch.isWhitespace && ch != ESC)-    // Lots of binary chars - translate all supposed whitespace into spaces-    // except supposed line endings, otherwise scrubbed lines run together-    if (binaryChars > 5) // more than one can count while holding a hamburger-      cleaned map {-        case c if lineSeparator contains c => c-        case c if c.isWhitespace => ' '-        case c if c < 32 => '?'-        case c => c-      }-    // Not lots - preserve whitespace and ESC-    else-      cleaned map (ch => if (ch.isWhitespace || ch == ESC) ch else if (ch < 32) '?' else ch)-  }+  // The CSI pattern matches a subset of the following spec:+  // For CSI, or "Control Sequence Introducer" commands,+  // the ESC [ is followed by any number (including none) of "parameter bytes" in the range 0x30–0x3F (ASCII 0–9:;<=>?),+  // then by any number of "intermediate bytes" in the range 0x20–0x2F (ASCII space and !"#$%&'()*+,-./),+  // then finally by a single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~)+  private final val esc = "\u001b"    // "\N{escape}"+  private val csi = raw"$esc\[[0-9;]*([\x40-\x7E])"++  // Matches one of 3 alternatives:+  // group 1 is the CSI command letter, where 'm' is color rendition+  // group 2 is a sequence of chars to be rendered as `?`: anything non-printable and not some space char+  // additional groups are introduced by linePattern but not used+  private lazy val cleaner = raw"$csi|([^\p{Print}\p{Space}]+)|$linePattern".r

  package scala.tools.nsc.interpreter -import scala.util.Properties.lineSeparator import scala.util.matching.Regex  /** This is for name logic which is independent of the compiler (notice there's no Global.)  *  That includes at least generating, metaquoting, mangling, and unmangling.  */ object Naming {-  def unmangle(str: String): String = {-    val ESC = '\u001b'-    val cleaned = lineRegex.replaceAllIn(str, "")-    // Looking to exclude binary data which hoses the terminal, but-    // let through the subset of it we need, like whitespace and also-    // <ESC> for ansi codes.-    val binaryChars = cleaned count (ch => ch < 32 && !ch.isWhitespace && ch != ESC)-    // Lots of binary chars - translate all supposed whitespace into spaces-    // except supposed line endings, otherwise scrubbed lines run together-    if (binaryChars > 5) // more than one can count while holding a hamburger-      cleaned map {-        case c if lineSeparator contains c => c-        case c if c.isWhitespace => ' '-        case c if c < 32 => '?'-        case c => c-      }-    // Not lots - preserve whitespace and ESC-    else-      cleaned map (ch => if (ch.isWhitespace || ch == ESC) ch else if (ch < 32) '?' else ch)-  }+  // The CSI pattern matches a subset of the following spec:+  // For CSI, or "Control Sequence Introducer" commands,+  // the ESC [ is followed by any number (including none) of "parameter bytes" in the range 0x30–0x3F (ASCII 0–9:;<=>?),+  // then by any number of "intermediate bytes" in the range 0x20–0x2F (ASCII space and !"#$%&'()*+,-./),+  // then finally by a single "final byte" in the range 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~)+  private final val esc = "\u001b"    // "\N{escape}"+  private val csi = raw"$esc\[[0-9;]*([\x40-\x7E])"++  // Matches one of 3 alternatives:+  // group 1 is the CSI command letter, where 'm' is color rendition+  // group 2 is a sequence of chars to be rendered as `?`: anything non-printable and not some space char+  // additional groups are introduced by linePattern but not used+  private lazy val cleaner = raw"$csi|([^\p{Print}\p{Space}]+)|$linePattern".r

 trait Scanners extends ScannersCommon {         }       } else if (ch == '$') {         nextRawChar()-        if (ch == '$') {+        if (ch == '$' || (currentRun.isScala3 && ch == '"')) {

 trait Scanners extends ScannersCommon {         }       } else if (ch == '$') {         nextRawChar()-        if (ch == '$') {+        if (ch == '$' || (currentRun.isScala3 && ch == '"')) {

 trait Scanners extends ScannersCommon {         }       } else if (ch == '$') {         nextRawChar()-        if (ch == '$') {+        if (ch == '$' || (currentRun.isScala3 && ch == '"')) {