Reinstate deprecation of unicode arrows (⇒ & ←)

Unicode arrows are deprecated in Scala 2.13, thanks to
scala/scala#7540 merged in January 2019. For
consistency, unless there's been a conscious decision to _un_deprecate
them, we should continue that on into Scala 3.

Author: rtyley

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -879,9 +879,11 @@ object Scanners {
         case _ =>
           def fetchOther() =
             if (ch == '\u21D2') {
+              report.deprecationWarning("The unicode arrow `⇒` is deprecated, use `=>` instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.", sourcePos(offset))
               nextChar(); token = ARROW
             }
             else if (ch == '\u2190') {
+              report.deprecationWarning("The unicode arrow `←` is deprecated, use `<-` instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.", sourcePos(offset))
               nextChar(); token = LARROW
             }
             else if (Character.isUnicodeIdentifierStart(ch)) {

sbt-test/sbt-dotty/scaladoc/src/main/scala/ImpliedInstances.scala

@@ -16,17 +16,17 @@ object ImpliedInstances {
 
     def apply[A](using parser: StringParser[A]): StringParser[A] = parser
 
-    private def baseParser[A](f: String ⇒ Try[A]): StringParser[A] = new StringParser[A] {
+    private def baseParser[A](f: String => Try[A]): StringParser[A] = new StringParser[A] {
       override def parse(s: String): Try[A] = f(s)
     }
 
     given stringParser: StringParser[String] = baseParser(Success(_))
-    given intParser: StringParser[Int] = baseParser(s ⇒ Try(s.toInt))
+    given intParser: StringParser[Int] = baseParser(s => Try(s.toInt))
 
     given optionParser[A](using parser: => StringParser[A]): StringParser[Option[A]] = new StringParser[Option[A]] {
       override def parse(s: String): Try[Option[A]] = s match {
-        case "" ⇒ Success(None) // implicit parser not used.
-        case str ⇒ parser.parse(str).map(x ⇒ Some(x)) // implicit parser is evaluated at here
+        case "" => Success(None) // implicit parser not used.
+        case str => parser.parse(str).map(x => Some(x)) // implicit parser is evaluated at here
       }
     }
   }

scaladoc/src/dotty/tools/scaladoc/util/JSON.scala

@@ -31,7 +31,7 @@ def jsonString(s: String): JSON =
 
     sb.append('"')
     firstToBeEncoded() match
-      case -1 ⇒ sb.append(s)
+      case -1 => sb.append(s)
       case first =>
         // sb.append(s, 0, first) for "abc", 0, 2 produce "(abc,0,2)" rather then "ab" as in Java
         sb.append(s.substring(0, first))

tests/disabled/macro/run/t7240/Macros_1.scala

@@ -22,9 +22,9 @@ object Bakery {
 
       val tpeName = newTypeName(names.head)
       names.tail.reverse match {
-        case head :: tail ⇒
-          Select(tail.foldLeft[Tree](Ident(newTermName(head)))((tree, name) ⇒ Select(tree, newTermName(name))), tpeName)
-        case Nil ⇒
+        case head :: tail =>
+          Select(tail.foldLeft[Tree](Ident(newTermName(head)))((tree, name) => Select(tree, newTermName(name))), tpeName)
+        case Nil =>
           Ident(tpeName)
       }
     }

tests/patmat/t11620.scala

@@ -19,20 +19,20 @@ object B {
 }
 
 def foo[T](b: B[T]) = b match {
-  case B(A1(t)) ⇒ t
-  case B(A2(t, _)) ⇒ t
+  case B(A1(t)) => t
+  case B(A2(t, _)) => t
 }
 
 def foo2[_A[+U] <: A[U], T](b: B.Aux[_A, T]) = b match {
-  case B.Aux(a @ A1(_   )) ⇒ a.t
-  case B.Aux(a @ A2(_, _)) ⇒ a.t1  // 👎 (false-positive): unreachable code
+  case B.Aux(a @ A1(_   )) => a.t
+  case B.Aux(a @ A2(_, _)) => a.t1  // 👎 (false-positive): unreachable code
 }
 
 def foo3[_A[+U] <: A[U], T](b: B.Aux[_A, T]) = b match {
-  case B.Aux(a: A1[T]) ⇒ a.t
-  case B.Aux(a: A2[T]) ⇒ a.t1  // 👎 (false-positive): unreachable code
+  case B.Aux(a: A1[T]) => a.t
+  case B.Aux(a: A2[T]) => a.t1  // 👎 (false-positive): unreachable code
 }
 
 def foo4[T](b: B[T]) = b match {
-  case B(A1(t)) ⇒ t  // 👎 (false-negative): incomplete match
+  case B(A1(t)) => t  // 👎 (false-negative): incomplete match
 }

tests/pending/i12194.scala

@@ -12,5 +12,5 @@ def f(): Unit =
 
 @main def Test(): Unit =
   println(summonAll[Tuple.Map[("foo", "bar"), ValueOf]].toList.map{
-    case str: ValueOf[_] ⇒ str.value
+    case str: ValueOf[_] => str.value
   })

tests/pending/pos/TypeIndexing.scala

@@ -10,7 +10,7 @@
 
 object Test {
   def use(a : A) = a match  {
-    case b @ A(t) ⇒
+    case b @ A(t) =>
       val s: b.T = t // type mismatch.
                      // found t.type (with underlying type <unapply-selector>.T)
                      // required: a.T

tests/pending/run/t8091.scala

@@ -1,4 +1,4 @@
 object Test extends App {
-  val result = "börk börk" flatMap (ch ⇒ if (ch > 127) f"&#x${ch}%04x;" else "" + ch)
+  val result = "börk börk" flatMap (ch => if (ch > 127) f"&#x${ch}%04x;" else "" + ch)
   println(result)
 }

tests/pos-special/utf16encoded.scala

@@ -1,7 +1,7 @@
 //this file is saved as UTF-8
 object Test {
   def main(args: Array[String]): Unit = {
-    val testchar = '⇒'
+    val testchar = '=>'
     println(testchar == '\u21D2')
   }
 

tests/pos-special/utf8encoded.scala

@@ -6,7 +6,7 @@ trait A {
   def trans[A] (x : A) (implicit f : A => A) = f(x)
 }
 object Test extends A with App {
-  implicit def succ : Int ⇒ Int = x ⇒ x + 1 // (3)
+  implicit def succ : Int => Int = x => x + 1 // (3)
   def bad [A] (x : A) : A = trans[A](x) // (4) incoherent de€nition !
   val v1 = bad [Int] (3) // (5) evaluates to 3
   val v2 = trans [Int] (3) // (6) substituting bad by trans is rejected