add ** operator and stringifies bigint as string in JSON

Author: gfx

README.md

@@ -131,7 +131,7 @@ This is a list of features in ECMA-262 that are planned or implemented ("[x]" do
 * [ ] index access (`[0]` and `.["foo"]`)
 * [ ] property access (`.foo`)
 * [ ] `typeof` operator
-* [ ] [WIP] arithmetic operators (`+`, `-`, `*`, `/`, `%`, `**`)
+* [x] arithmetic operators (`+`, `-`, `*`, `/`, `%`, `**`)
 * [x] bitwise operators (`~`, `&`, `|`, `^`, `<<`, `>>`, `>>>`)
 * [ ] assignment operators (`=`, `+=`, `-=`, `*=`, `/=`, `%=`, `**=`, `<<=`, `>>=`, `>>>=`, `&=`, `|=`, `^=`)
 * [x] comparison operators (`==`, `!=`, `===`, `!==`, `<`, `>`, `<=`, `>=`)

spec/pow.ts

@@ -0,0 +1,4 @@
+export const a = 1 ** 1;
+export const b = 2 ** 32;
+export const c = 2n ** 32n;
+export const d = 2n ** 50n;

spec/pow.ts.stdout

@@ -0,0 +1,6 @@
+{
+  "a": 1,
+  "b": 4294967296,
+  "c": "4294967296",
+  "d": "1125899906842624"
+}

src/ast.rs

@@ -60,6 +60,7 @@ pub enum ExprEnum<'src> {
     Mul(Box<Expression<'src>>, Box<Expression<'src>>),
     Div(Box<Expression<'src>>, Box<Expression<'src>>),
     Mod(Box<Expression<'src>>, Box<Expression<'src>>),
+    Pow(Box<Expression<'src>>, Box<Expression<'src>>),
     BwOr(Box<Expression<'src>>, Box<Expression<'src>>),
     BwAnd(Box<Expression<'src>>, Box<Expression<'src>>),
     BwXor(Box<Expression<'src>>, Box<Expression<'src>>),

src/compiler.rs

@@ -221,6 +221,7 @@ impl Compiler {
             ExprEnum::Mul(lhs, rhs) => self.bin_op(OpCode::Mul, lhs, rhs)?,
             ExprEnum::Div(lhs, rhs) => self.bin_op(OpCode::Div, lhs, rhs)?,
             ExprEnum::Mod(lhs, rhs) => self.bin_op(OpCode::Mod, lhs, rhs)?,
+            ExprEnum::Pow(lhs, rhs) => self.bin_op(OpCode::Pow, lhs, rhs)?,
             ExprEnum::BwOr(lhs, rhs) => self.bin_op(OpCode::BwOr, lhs, rhs)?,
             ExprEnum::BwAnd(lhs, rhs) => self.bin_op(OpCode::BwAnd, lhs, rhs)?,
             ExprEnum::BwXor(lhs, rhs) => self.bin_op(OpCode::BwXor, lhs, rhs)?,

src/instructions.rs

@@ -15,8 +15,9 @@ pub enum OpCode {
     Add,
     Sub,
     Mul,
-    Mod,
     Div,
+    Mod,
+    Pow,
     BwOr,
     BwAnd,
     BwXor,

src/main.rs

@@ -301,12 +301,12 @@ mod tests {
             result,
             json!(
                 {
-                    "zero": 0,
-                    "answer": 42,
-                    "minus": -42,
-                    "w_underscore": 1000000,
-                    "i32_max": 2147483647i32,
-                    "i64_max": 9223372036854775807i64
+                    "zero": "0",
+                    "answer": "42",
+                    "minus": "-42",
+                    "w_underscore": "1000000",
+                    "i32_max": "2147483647",
+                    "i64_max": "9223372036854775807"
                 }
             )
         );
@@ -320,7 +320,7 @@ mod tests {
         "#,
         )
         .unwrap();
-        assert_eq!(result, json!({ "a": 43 }));
+        assert_eq!(result, json!({ "a": "43" }));
     }
 
     #[test]
@@ -331,7 +331,7 @@ mod tests {
         "#,
         )
         .unwrap();
-        assert_eq!(result, json!({ "a": 41 }));
+        assert_eq!(result, json!({ "a": "41" }));
     }
 
     #[test]
@@ -342,7 +342,7 @@ mod tests {
         "#,
         )
         .unwrap();
-        assert_eq!(result, json!({ "a": 84 }));
+        assert_eq!(result, json!({ "a": "84" }));
     }
 
     #[test]
@@ -353,7 +353,7 @@ mod tests {
         "#,
         )
         .unwrap();
-        assert_eq!(result, json!({ "a": 14 }));
+        assert_eq!(result, json!({ "a": "14" }));
     }
 
     // TODO: literal types are not yet supported so the error message does not match TypeScript compiler's.

src/parser.rs

@@ -118,8 +118,8 @@ fn unary_op(i: Span) -> IResult<Span, Expression> {
     }
 }
 
-fn factor(i: Span) -> IResult<Span, Expression> {
-    alt((
+fn factor(input: Span) -> IResult<Span, Expression> {
+    let (i, expr) = alt((
         undefined_literal,
         null_literal,
         true_literal,
@@ -134,7 +134,21 @@ fn factor(i: Span) -> IResult<Span, Expression> {
         func_call,
         ident,
         parens,
-    ))(i)
+    ))(input)?;
+
+    let Ok((i, _)) = tag::<&str, Span, Error>("**")(i) else {
+        return Ok((i, expr));
+    };
+
+    let (i, rhs) = space_delimited(factor)(i)?;
+    Ok((
+        i,
+        Expression {
+            expr: ExprEnum::Pow(Box::new(expr), Box::new(rhs)),
+            span: input,
+        },
+    ))
+
 }
 
 fn func_call(i: Span) -> IResult<Span, Expression> {

src/ser.rs

@@ -20,7 +20,7 @@ impl Serialize for Value {
                     serializer.serialize_f64(*value)
                 }
             }
-            Self::Int(value) => serializer.serialize_i64(*value),
+            Self::Int(value) => serializer.serialize_str(value.to_string().as_str()),
             Self::Str(value) => serializer.serialize_str(value),
             Self::Array(value) => value.serialize(serializer),
             Self::Object(value) => {

src/type_checker.rs

@@ -275,6 +275,7 @@ fn tc_expr<'src>(
         Mul(lhs, rhs) => tc_bin_arithmetic_op(lhs, rhs, ctx, "*")?,
         Div(lhs, rhs) => tc_bin_arithmetic_op(lhs, rhs, ctx, "/")?,
         Mod(lhs, rhs) => tc_bin_arithmetic_op(lhs, rhs, ctx, "%")?,
+        Pow(lhs, rhs) => tc_bin_arithmetic_op(lhs, rhs, ctx, "**")?,
         BwAnd(lhs, rhs) => tc_bin_arithmetic_op(lhs, rhs, ctx, "&")?,
         BwOr(lhs, rhs) => tc_bin_arithmetic_op(lhs, rhs, ctx, "|")?,
         BwXor(lhs, rhs) => tc_bin_arithmetic_op(lhs, rhs, ctx, "^")?,