correctly parse enum values

enum values can be expressions including
- unary operators
- binary operators
- string and number literals
- parenthesis
- identifiers

See:
https://github.com/microsoft/TypeScript/blob/master/doc/spec.md#92-enum-members
https://github.com/microsoft/TypeScript/blob/master/doc/spec.md#419-binary-operators

Note:
this implementation performs a flat parse that neither
handles expression-tree-building nor operator precedences.

Note:
This commit removes the minus from the NumericLit-token and
parses it explicitly in TSDefParser.numberLiteral

Author: SrTobi

samples/valueExpression.d.ts

@@ -0,0 +1,12 @@
+declare module valueExpression {
+    export enum StringEnum {
+        A = "test",
+        B = A,
+        C = "test" + "test"
+    }
+    export enum NumberEnum {
+        A = 3 + 3,
+        B = 1 << 3,
+        C = 10**2+1*8- - -3/3>>2<<3>>>+19%~~~3+ + +9
+    }
+}

samples/valueExpression.d.ts.scala

@@ -0,0 +1,40 @@
+
+import scala.scalajs.js
+import js.annotation._
+import js.|
+
+package valueExpression {
+
+package valueExpression {
+
+@js.native
+sealed trait StringEnum extends js.Object {
+}
+
+@js.native
+@JSGlobal("valueExpression.StringEnum")
+object StringEnum extends js.Object {
+  var A: StringEnum = js.native
+  var B: StringEnum = js.native
+  var C: StringEnum = js.native
+  @JSBracketAccess
+  def apply(value: StringEnum): String = js.native
+}
+
+@js.native
+sealed trait NumberEnum extends js.Object {
+}
+
+@js.native
+@JSGlobal("valueExpression.NumberEnum")
+object NumberEnum extends js.Object {
+  var A: NumberEnum = js.native
+  var B: NumberEnum = js.native
+  var C: NumberEnum = js.native
+  @JSBracketAccess
+  def apply(value: NumberEnum): String = js.native
+}
+
+}
+
+}

src/main/scala/org/scalajs/tools/tsimporter/parser/TSDefLexical.scala

@@ -42,8 +42,8 @@ class TSDefLexical extends Lexical with StdTokens with ImplicitConversions {
             digits => digits.foldLeft(0L)(_ * 8 + _).toString
           }
       )
-    | opt('-')  ~ stringOf1(digit) ~ opt(stringOf1('.', digit)) ^^ {
-        case sign ~ part1 ~ part2 => sign.getOrElse("") + part1 + (part2.getOrElse(""))
+    | stringOf1(digit) ~ opt(stringOf1('.', digit)) ^^ {
+        case part1 ~ part2 => part1 + part2.getOrElse("")
       }
   ) ^^ NumericLit
 

src/main/scala/org/scalajs/tools/tsimporter/parser/TSDefParser.scala

@@ -46,6 +46,18 @@ class TSDefParser extends StdTokenParsers with ImplicitConversions {
       "...", "=>"
   )
 
+  // for value expressions
+  val binaryValueOperators = Set(
+    "+", "-", "*", "/", "**", "%",
+    "<<", ">>>", ">>", "&", "|", "^"
+  )
+  lexical.delimiters ++= binaryValueOperators
+
+  val unaryValueOperators = Set(
+    "+", "-", "~"
+  )
+  lexical.delimiters ++= unaryValueOperators
+
   def parseDefinitions(input: Reader[Char]) =
     phrase(ambientDeclarations)(new lexical.Scanner(input))
 
@@ -105,7 +117,20 @@ class TSDefParser extends StdTokenParsers with ImplicitConversions {
     "enum" ~> typeName ~ ("{" ~> ambientEnumBody <~ "}") ^^ EnumDecl
 
   lazy val ambientEnumBody: Parser[List[Ident]] =
-    repsep(identifier <~ opt("=" ~ (numericLit | stringLit) ), ",") <~ opt(",")
+    repsep(identifier <~ opt("=" ~! valueExpression), ",") <~ opt(",")
+
+  lazy val valueExpression: Parser[_] =
+    rep1sep(success() ~>! rep(unaryValueOperator) ~
+      (numericLit | stringLit | identifierName | parenthesizedValueExpression), binaryValueOperator)
+
+  lazy val parenthesizedValueExpression =
+    "(" ~! valueExpression ~ ")"
+
+  lazy val binaryValueOperator =
+    elem("binary operator", tok => binaryValueOperators.contains(tok.chars))
+
+  lazy val unaryValueOperator =
+    elem("unary operator", tok => unaryValueOperators.contains(tok.chars))
 
   lazy val ambientClassDecl: Parser[DeclTree] =
     (abstractModifier <~ "class") ~ typeName ~ tparams ~ classParent ~ classImplements ~ memberBlock <~ opt(";") ^^ {
@@ -342,8 +367,8 @@ class TSDefParser extends StdTokenParsers with ImplicitConversions {
     stringLit ^^ StringLiteral
 
   lazy val numberLiteral: Parser[NumberLiteral] =
-    numericLit ^^ { s =>
-      val d = s.toDouble
+    opt("-") ~ numericLit ^^ { case minus ~ s =>
+      val d = (minus.getOrElse("") + s).toDouble
       if (!s.contains(".") && d.isValidInt) {
         IntLiteral(d.toInt)
       } else {