port constant types for literal final static java fields

Author: noti0na1

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

@@ -807,6 +807,7 @@ object StdNames {
     final val ELSEkw: N         = kw("else")
     final val ENUMkw: N         = kw("enum")
     final val EXTENDSkw: N      = kw("extends")
+    final val FALSEkw: N        = kw("false")
     final val FINALkw: N        = kw("final")
     final val FINALLYkw: N      = kw("finally")
     final val FLOATkw: N        = kw("float")
@@ -836,6 +837,7 @@ object StdNames {
     final val THROWkw: N        = kw("throw")
     final val THROWSkw: N       = kw("throws")
     final val TRANSIENTkw: N    = kw("transient")
+    final val TRUEkw: N         = kw("true")
     final val TRYkw: N          = kw("try")
     final val VOIDkw: N         = kw("void")
     final val VOLATILEkw: N     = kw("volatile")

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

@@ -601,9 +601,53 @@ object JavaParsers {
 
     def varDecl(mods: Modifiers, tpt: Tree, name: TermName): ValDef = {
       val tpt1 = optArrayBrackets(tpt)
-      if (in.token == EQUALS && !mods.is(Flags.Param)) skipTo(COMMA, SEMI)
+      /** Tries to detect final static literals syntactically and returns a constant type replacement */
+      def optConstantTpe(): Tree = {
+        def constantTpe(const: Constant): Tree = TypeTree(ConstantType(const))
+
+        def forConst(const: Constant): Tree = {
+          if (in.token != SEMI) tpt1
+          else {
+            def isStringTyped = tpt1 match {
+              case Ident(n: TypeName) => "String" == n.toString
+              case _ => false
+            }
+            if (const.tag == Constants.StringTag && isStringTyped) constantTpe(const)
+            else tpt1 match {
+              case TypedSplice(tpt2) =>
+                if (const.tag == Constants.BooleanTag || const.isNumeric) {
+                  //for example, literal 'a' is ok for float. 127 is ok for byte, but 128 is not.
+                  val converted = const.convertTo(tpt2.tpe)
+                  if (converted == null) tpt1
+                  else constantTpe(converted)
+                }
+                else tpt1
+              case _ => tpt1
+            }
+          }
+        }
+
+        in.nextToken() // EQUALS
+        if (mods.is(Flags.JavaStatic) && mods.is(Flags.Final)) {
+          val neg = in.token match {
+            case MINUS | BANG => in.nextToken(); true
+            case _ => false
+          }
+          tryLiteral(neg).map(forConst).getOrElse(tpt1)
+        }
+        else tpt1
+      }
+
+      val tpt2: Tree =
+        if (in.token == EQUALS && !mods.is(Flags.Param)) {
+          val res = optConstantTpe()
+          skipTo(COMMA, SEMI)
+          res
+        }
+        else tpt1
+
       val mods1 = if (mods.is(Flags.Final)) mods else mods | Flags.Mutable
-      ValDef(name, tpt1, if (mods.is(Flags.Param)) EmptyTree else unimplementedExpr).withMods(mods1)
+      ValDef(name, tpt2, if (mods.is(Flags.Param)) EmptyTree else unimplementedExpr).withMods(mods1)
     }
 
     def memberDecl(start: Offset, mods: Modifiers, parentToken: Int, parentTParams: List[TypeDef]): List[Tree] = in.token match {
@@ -881,6 +925,25 @@ object JavaParsers {
       case _         => in.nextToken(); syntaxError("illegal start of type declaration", skipIt = true); List(errorTypeTree)
     }
 
+    def tryLiteral(negate: Boolean = false): Option[Constant] = {
+      val l = in.token match {
+        case TRUE      => !negate
+        case FALSE     => negate
+        case CHARLIT   => in.strVal.charAt(0)
+        case INTLIT    => in.intVal(negate).toInt
+        case LONGLIT   => in.intVal(negate)
+        case FLOATLIT  => in.floatVal(negate).toFloat
+        case DOUBLELIT => in.floatVal(negate)
+        case STRINGLIT => in.strVal
+        case _         => null
+      }
+      if (l == null) None
+      else {
+        in.nextToken()
+        Some(Constant(l))
+      }
+    }
+
     /** CompilationUnit ::= [package QualId semi] TopStatSeq
       */
     def compilationUnit(): Tree = {

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

@@ -479,6 +479,54 @@ object JavaScanners {
       setStrVal()
     }
 
+    /** convert name to long value
+     */
+    def intVal(negated: Boolean): Long =
+      if (token == CHARLIT && !negated)
+        if (strVal.length > 0) strVal.charAt(0).toLong else 0
+      else {
+        var value: Long = 0
+        val divider = if (base == 10) 1 else 2
+        val limit: Long =
+          if (token == LONGLIT) Long.MaxValue else Int.MaxValue
+        var i = 0
+        val len = strVal.length
+        while (i < len) {
+          val d = digit2int(strVal.charAt(i), base)
+          if (d < 0) {
+            error("malformed integer number")
+            return 0
+          }
+          if (value < 0 ||
+              limit / (base / divider) < value ||
+              limit - (d / divider) < value * (base / divider) &&
+              !(negated && limit == value * base - 1 + d)) {
+                error("integer number too large")
+                return 0
+              }
+          value = value * base + d
+          i += 1
+        }
+        if (negated) -value else value
+      }
+
+    /** convert name, base to double value
+     */
+    def floatVal(negated: Boolean): Double = {
+      val limit: Double =
+        if (token == DOUBLELIT) Double.MaxValue else Float.MaxValue
+      try {
+        val value: Double = java.lang.Double.valueOf(strVal.toString).doubleValue()
+        if (value > limit)
+          error("floating point number too large")
+        if (negated) -value else value
+      } catch {
+        case _: NumberFormatException =>
+          error("malformed floating point number")
+          0.0
+      }
+    }
+
     /** read a number into name and set base
       */
     protected def getNumber(): Unit = {