Accept 0x_42, reject 0x

Forward port fix on 2.11 for `0x`.

2.13 accepts 0x_42 and was affirmed.

Also accept leading zero for decimals.
People like their literals to align left and right.
List(0000, 3.14) will harmonize vertically!

Leading zero is lintable in 2.13.

Author: som-snytt

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

@@ -129,12 +129,11 @@ object Scanners {
 
     @inline def isNumberSeparator(c: Char): Boolean = c == '_'
 
-    @inline def removeNumberSeparators(s: String): String =
-      if (s.indexOf('_') > 0) s.replaceAllLiterally("_", "") else s
+    @inline def removeNumberSeparators(s: String): String = if (s.indexOf('_') == -1) s else s.replace("_", "")
 
     // disallow trailing numeric separator char, but continue lexing
     def checkNoTrailingSeparator(): Unit =
-      if (isNumberSeparator(litBuf.last))
+      if (!litBuf.isEmpty && isNumberSeparator(litBuf.last))
         errorButContinue("trailing separator is not allowed", offset + litBuf.length - 1)
   }
 
@@ -706,28 +705,18 @@ object Scanners {
             getOperatorRest()
           }
         case '0' =>
-          def fetchZero() = {
-            putChar(ch)
+          def fetchLeadingZero(): Unit = {
             nextChar()
-            if (ch == 'x' || ch == 'X') {
-              nextChar()
-              base = 16
-              if (isNumberSeparator(ch))
-                errorButContinue("leading separator is not allowed", offset + 2)
+            ch match {
+              case 'x' | 'X' => base = 16 ; nextChar()
+              //case 'b' | 'B' => base = 2  ; nextChar()
+              case _         => base = 10 ; putChar('0')
             }
-            else {
-              /**
-               * What should leading 0 be in the future? It is potentially dangerous
-               *  to let it be base-10 because of history.  Should it be an error? Is
-               *  there a realistic situation where one would need it?
-               */
-              if (isDigit(ch) || (isNumberSeparator(ch) && isDigit(lookaheadChar())))
-                error("Numbers may not have a leading zero.")
-              base = 10
-            }
-            getNumber()
+            if (base != 10 && !isNumberSeparator(ch) && digit2int(ch, base) < 0)
+              error("invalid literal number")
           }
-          fetchZero()
+          fetchLeadingZero()
+          getNumber()
         case '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' =>
           base = 10
           getNumber()

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -633,11 +633,11 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       lazy val actualErrors = reporters.foldLeft(0)(_ + _.errorCount)
       def hasMissingAnnotations = getMissingExpectedErrors(errorMap, reporters.iterator.flatMap(_.errors))
 
-      if (compilerCrashed) Some(s"Compiler crashed when compiling: ${testSource.title}"                                                             )
-      else if (actualErrors == 0) Some(s"\nNo errors found when compiling neg test $testSource"                                                            )
+      if (compilerCrashed) Some(s"Compiler crashed when compiling: ${testSource.title}")
+      else if (actualErrors == 0) Some(s"\nNo errors found when compiling neg test $testSource")
       else if (expectedErrors != actualErrors) Some(s"\nWrong number of errors encountered when compiling $testSource, expected: $expectedErrors, actual: $actualErrors")
-      else if (hasMissingAnnotations) Some(s"\nErrors found on incorrect row numbers when compiling $testSource"                                               )
-      else if (!errorMap.isEmpty) Some(s"\nExpected error(s) have {<error position>=<unreported error>}: $errorMap"                                        )
+      else if (hasMissingAnnotations) Some(s"\nErrors found on incorrect row numbers when compiling $testSource")
+      else if (!errorMap.isEmpty) Some(s"\nExpected error(s) have {<error position>=<unreported error>}: $errorMap")
       else None
     }
 

tests/neg/literals.scala

@@ -0,0 +1,58 @@
+trait RejectedLiterals {
+  def missingHex: Int    = { 0x }        // error: invalid literal number
+}
+/*
+// scalac: -Ywarn-octal-literal -Xfatal-warnings -deprecation
+trait RejectedLiterals {
+
+  def missingHex: Int    = { 0x }        // line 4: was: not reported, taken as zero
+
+  def leadingZeros: Int  = { 01 }        // line 6: no leading zero
+
+  def tooManyZeros: Int  = { 00 }        // line 8: no leading zero
+
+  def zeroOfNine: Int    = { 09 }        // line 10: no leading zero
+
+  def orphanDot: Int     = { 9. }        // line 12: ident expected
+
+  def zeroOfNineDot: Int = { 09. }       // line 14: malformed integer, ident expected
+
+  def noHexFloat: Double = { 0x1.2 }     // line 16: ';' expected but double literal found.
+
+}
+
+trait Braceless {
+
+  def missingHex: Int    = 0x            // line 22: was: not reported, taken as zero
+
+  def leadingZeros: Int  = 01            // line 24: no leading zero
+
+  def tooManyZeros: Int  = 00            // line 26: no leading zero
+
+  def zeroOfNine: Int    = 09            // line 28: no leading zero
+
+  def orphanDot: Int     = 9.            // line 30: ident expected
+
+  def zeroOfNineDot: Int = 09.           // line 32: malformed integer, ident expected
+
+  def noHexFloat: Double = 0x1.2         // line 34: ';' expected but double literal found.
+}
+
+trait MoreSadness {
+
+  def tooTiny: Float     = { 0.7e-45f }      // floating point number too small
+
+  def twoTiny: Double    = { 2.0e-324 }      // double precision floating point number too small
+
+  def tooHuge: Float     = { 3.4028236E38f } // floating point number too large
+
+  def twoHuge: Double    = { 1.7976931348623159e308 } // double precision floating point number too large
+}
+
+trait Lengthy {
+
+  def bad = 1l
+
+  def worse = 123l
+}
+*/

tests/neg/t6124.check

@@ -46,46 +46,10 @@
 24 |  val x5 = 0_x52 // error
    |            ^
    |            trailing separator is not allowed
--- Error: tests/neg/t6124.scala:25:13 ----------------------------------------------------------------------------------
-25 |  val x6 = 0x_52 // error
-   |             ^
-   |             leading separator is not allowed
--- Error: tests/neg/t6124.scala:26:14 ----------------------------------------------------------------------------------
+-- Error: tests/neg/t6124.scala:26:13 ----------------------------------------------------------------------------------
 26 |  val x8 = 0x52_ // error
-   |              ^
-   |              trailing separator is not allowed
--- Error: tests/neg/t6124.scala:27:11 ----------------------------------------------------------------------------------
-27 |  val x9 = 0_52 // error
-   |           ^
-   |           Numbers may not have a leading zero.
--- Error: tests/neg/t6124.scala:28:12 ----------------------------------------------------------------------------------
-28 |  val x10 = 052 // error
-   |            ^
-   |            Numbers may not have a leading zero.
--- Error: tests/neg/t6124.scala:29:12 ----------------------------------------------------------------------------------
-29 |  val x11 = 0_0.52 // error
-   |            ^
-   |            Numbers may not have a leading zero.
--- Error: tests/neg/t6124.scala:30:12 ----------------------------------------------------------------------------------
-30 |  val x12 = 00.52 // error
-   |            ^
-   |            Numbers may not have a leading zero.
--- Error: tests/neg/t6124.scala:31:12 ----------------------------------------------------------------------------------
-31 |  val x13 = 00 // error
-   |            ^
-   |            Numbers may not have a leading zero.
--- Error: tests/neg/t6124.scala:32:12 ----------------------------------------------------------------------------------
-32 |  val x14 = 00d // error
-   |            ^
-   |            Numbers may not have a leading zero.
--- Error: tests/neg/t6124.scala:33:12 ----------------------------------------------------------------------------------
-33 |  val x15 = 00.0 // error
-   |            ^
-   |            Numbers may not have a leading zero.
--- Error: tests/neg/t6124.scala:34:12 ----------------------------------------------------------------------------------
-34 |  val x16 = 0_0 // error
-   |            ^
-   |            Numbers may not have a leading zero.
+   |             ^
+   |             trailing separator is not allowed
 -- Error: tests/neg/t6124.scala:12:17 ----------------------------------------------------------------------------------
 12 |  def tooSmall = 1.0E-325 // error
    |                 ^^^^^^^^

tests/neg/t6124.scala

@@ -22,16 +22,16 @@ trait T {
   val x3 = 52_ // error
 
   val x5 = 0_x52 // error
-  val x6 = 0x_52 // error
+  val x6 = 0x_52
   val x8 = 0x52_ // error
-  val x9 = 0_52 // error
-  val x10 = 052 // error
-  val x11 = 0_0.52 // error
-  val x12 = 00.52 // error
-  val x13 = 00 // error
-  val x14 = 00d // error
-  val x15 = 00.0 // error
-  val x16 = 0_0 // error
+  val x9 = 0_52
+  val x10 = 052
+  val x11 = 0_0.52
+  val x12 = 00.52
+  val x13 = 00
+  val x14 = 00d
+  val x15 = 00.0
+  val x16 = 0_0
 
   def z = 0
 }

tests/run/literals.check

@@ -2,34 +2,23 @@
 // Literals
 //############################################################################
 
-//############################################################################
+import scala.util.{Failure, Success, Try}
 
 object Test {
 
-  /* I add a couple of Unicode identifier tests here temporarily */
+  /* I add a couple of Unicode identifier tests here "temporarily" */
 
   def \u03b1\u03c1\u03b5\u03c4\u03b7 = "alpha rho epsilon tau eta"
 
   case class GGG(i: Int) {
     def \u03b1\u03b1(that: GGG) = i + that.i
   }
 
-  def check_success[a](name: String, closure: => a, expected: a): Unit = {
-    print("test " + name)
-    try {
-      val actual: a = closure
-      if (actual == expected) {
-        print(" was successful");
-      } else {
-        print(" failed: expected "+ expected +", found "+ actual);
-      }
-    } catch {
-      case exception: Throwable => {
-        print(" raised exception " + exception);
-      }
+  def check_success[A](name: String, closure: => A, expected: A): Unit =
+    Try(closure) match {
+      case Success(actual) => assert(actual == expected, s"test $name failed: expected $expected, found $actual")
+      case Failure(error)  => throw new AssertionError(s"test $name raised exception $error")
     }
-    println
-  }
 
   def main(args: Array[String]): Unit = {
     // char
@@ -39,13 +28,9 @@ object Test {
     check_success("\"\\141\\142\" == \"ab\"", "\141\142", "ab")
     check_success("\"\\0x61\\0x62\".trim() == \"x61\\0x62\"", "\0x61\0x62".substring(1), "x61\0x62")
 
-    println
-
     // boolean
     check_success("(65 : Byte) == 'A'", (65: Byte) == 'A', true) // contrib #176
 
-    println
-
     // int
     check_success("0X01 == 1", 0X01, 1)
     check_success("0x01 == 1", 0x01, 1)
@@ -67,12 +52,10 @@ object Test {
     check_success("0x80000000 == -2147483648", 0x80000000, -2147483648)
     check_success("0xffffffff == -1", 0xffffffff, -1)
 
-    println
-
     // long
     check_success("1l == 1L", 1l, 1L)
     check_success("1L == 1l", 1L, 1l)
-    check_success("1.asInstanceOf[Long] == 1l", 1.asInstanceOf[Long], 1l)
+    check_success("1.asInstanceOf[Long] == 1L", 1.asInstanceOf[Long], 1L)
 
     check_success("0x7fffffffffffffffL == 9223372036854775807L",
       0x7fffffffffffffffL, 9223372036854775807L)
@@ -81,37 +64,48 @@ object Test {
     check_success("0xffffffffffffffffL == -1L",
       0xffffffffffffffffL, -1L)
 
-    println
-
     // see JLS at address:
     // http://java.sun.com/docs/books/jls/second_edition/html/lexical.doc.html#230798
 
     // float
     check_success("1e1f == 10.0f", 1e1f, 10.0f)
     check_success(".3f == 0.3f", .3f, 0.3f)
     check_success("0f == 0.0f", 0f, 0.0f)
+    check_success("0f == -0.000000000000000000e+00f", 0f, -0.000000000000000000e+00f)
+    check_success("0f == -0.000000000000000000e+00F", 0f, -0.000000000000000000e+00F)
+    check_success("0f == -0.0000000000000000e14f", 0f, -0.0000000000000000e14f)
+    check_success("01.23f == 1.23f", 01.23f, 1.23f)
     check_success("3.14f == 3.14f", 3.14f, 3.14f)
     check_success("6.022e23f == 6.022e23f", 6.022e23f, 6.022e23f)
-    check_success("09f == 9.0f", 9f, 9.0f)
+    check_success("9f == 9.0f", 9f, 9.0f)
+    check_success("09f == 9.0f", 09f, 9.0f)
+    check_success("1.00000017881393421514957253748434595763683319091796875001f == 1.0000001f",
+      1.00000017881393421514957253748434595763683319091796875001f,
+      1.0000001f)
+    check_success("3.4028235E38f == Float.MaxValue", 3.4028235E38f, Float.MaxValue)
     check_success("1.asInstanceOf[Float] == 1.0", 1.asInstanceOf[Float], 1.0f)
-    check_success("1l.asInstanceOf[Float] == 1.0", 1l.asInstanceOf[Float], 1.0f)
-
-    println
+    check_success("1L.asInstanceOf[Float] == 1.0", 1L.asInstanceOf[Float], 1.0f)
 
     // double
     check_success("1e1 == 10.0", 1e1, 10.0)
     check_success(".3 == 0.3", .3, 0.3)
     check_success("0.0 == 0.0", 0.0, 0.0)
     check_success("0d == 0.0", 0d, 0.0)
-    check_success("01.23 == 1.23", 1.23, 1.23)
+    check_success("0d == 0.000000000000000000e+00d", 0d, 0.000000000000000000e+00d)
+    check_success("0d == -0.000000000000000000e+00d", 0d, -0.000000000000000000e+00d)
+    check_success("0d == -0.000000000000000000e+00D", 0d, -0.000000000000000000e+00D)
+    check_success("0.0 == 0.000000000000000000e+00", 0.0, 0.000000000000000000e+00)
+    check_success("0.0 == -0.000000000000000000e+00", 0.0, -0.000000000000000000e+00)
+    check_success("1.23 == 1.23", 1.23, 1.23)
+    check_success("01.23 == 1.23", 01.23, 1.23)
     check_success("01.23d == 1.23d", 1.23d, 1.23d)
     check_success("3.14 == 3.14", 3.14, 3.14)
     check_success("1e-9d == 1.0e-9", 1e-9d, 1.0e-9)
     check_success("1e137 == 1.0e137", 1e137, 1.0e137)
+    check_success("1.7976931348623157e308d == Double.MaxValue", 1.7976931348623157e308d, Double.MaxValue)
     check_success("1.asInstanceOf[Double] == 1.0", 1.asInstanceOf[Double], 1.0)
-    check_success("1l.asInstanceOf[Double] == 1.0", 1l.asInstanceOf[Double], 1.0)
+    check_success("1L.asInstanceOf[Double] == 1.0", 1L.asInstanceOf[Double], 1.0)
 
-    println
     check_success("\"\".length()", "\u001a".length(), 1)
 
     val ggg = GGG(1) \u03b1\u03b1 GGG(2)