add ** operator and stringifies bigint as string in JSON

gfx · Aug 9, 2024 · ad11123 · ad11123
1 parent ebce991
commit ad11123
Show file tree

Hide file tree

Showing 12 changed files with 62 additions and 17 deletions.
diff --git a/README.md b/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 (`==`, `!=`, `===`, `!==`, `<`, `>`, `<=`, `>=`)

diff --git a/spec/pow.ts b/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;
diff --git a/spec/pow.ts.stdout b/spec/pow.ts.stdout
@@ -0,0 +1,6 @@
+{
+  "a": 1,
+  "b": 4294967296,
+  "c": "4294967296",
+  "d": "1125899906842624"
+}
diff --git a/src/ast.rs b/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>>),

diff --git a/src/compiler.rs b/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)?,

diff --git a/src/instructions.rs b/src/instructions.rs
@@ -15,8 +15,9 @@ pub enum OpCode {
     Add,
     Sub,
     Mul,
-    Mod,
     Div,
+    Mod,
+    Pow,
     BwOr,
     BwAnd,
     BwXor,

diff --git a/src/main.rs b/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.

diff --git a/src/parser.rs b/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> {

diff --git a/src/ser.rs b/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) => {

diff --git a/src/type_checker.rs b/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, "^")?,

diff --git a/src/vm.rs b/src/vm.rs
@@ -114,6 +114,16 @@ fn bin_op_mod(lhs: &Value, rhs: &Value) -> Result<Value, Box<dyn Error>> {
     }
 }
 
+fn bin_op_pow(lhs: &Value, rhs: &Value) -> Result<Value, Box<dyn Error>> {
+    match (lhs, rhs) {
+        (Value::Num(lhs), Value::Num(rhs)) => Ok(Value::Num(lhs.powf(*rhs))),
+        (Value::Int(lhs), Value::Int(rhs)) => Ok(Value::Int(
+            lhs.saturating_pow((*rhs).min(u32::MAX as i64) as u32),
+        )), // when overflowed, returns i64::MAX
+        _ => Err(err_bin_op("**", lhs, rhs)),
+    }
+}
+
 fn bin_op_bw_or(lhs: &Value, rhs: &Value) -> Result<Value, Box<dyn Error>> {
     match (lhs, rhs) {
         (Value::Num(lhs), Value::Num(rhs)) => Ok(Value::Num((*lhs as i32 | *rhs as i32) as f64)),
@@ -445,6 +455,7 @@ impl Vm {
                 OpCode::Mul => Self::interpret_bin_op(&mut self.top_mut()?.stack, bin_op_mul)?,
                 OpCode::Div => Self::interpret_bin_op(&mut self.top_mut()?.stack, bin_op_div)?,
                 OpCode::Mod => Self::interpret_bin_op(&mut self.top_mut()?.stack, bin_op_mod)?,
+                OpCode::Pow => Self::interpret_bin_op(&mut self.top_mut()?.stack, bin_op_pow)?,
                 OpCode::BwOr => Self::interpret_bin_op(&mut self.top_mut()?.stack, bin_op_bw_or)?,
                 OpCode::BwAnd => Self::interpret_bin_op(&mut self.top_mut()?.stack, bin_op_bw_and)?,
                 OpCode::BwXor => Self::interpret_bin_op(&mut self.top_mut()?.stack, bin_op_bw_xor)?,

diff --git a/tiscript2json/index.mjs b/tiscript2json/index.mjs
@@ -71,5 +71,11 @@ if (emitResult.emitSkipped) {
     fs.renameSync(jsFile, mjsFile);
   }
   const result = await import(mjsFile);
-  console.log(JSON.stringify(result, null, 2));
+  console.log(JSON.stringify(result, (_key, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    } else {
+      return value;
+    }
+  }, 2));
 }