clean up

Author: mununki

jscomp/core/js_analyzer.ml

@@ -158,8 +158,8 @@ let rec eq_expression ({ expression_desc = x0 } : J.expression)
   | Undefined x -> y0 = Undefined x
   | Number (Int { i }) -> (
       match y0 with Number (Int { i = j }) -> i = j | _ -> false)
-  | Number (Bigint (s0, i )) -> (
-    match y0 with Number (Bigint (s1, j)) -> s0 = s1 && i = j | _ -> false)
+  | Number (Bigint {positive = p0; value = v0}) -> (
+    match y0 with Number (Bigint {positive = p1; value = v1}) -> p0 = p1 && v0 = v1 | _ -> false)
   | Number (Float _) -> false
   (* begin match y0 with
      | Number (Float j) ->

jscomp/core/js_dump.ml

@@ -664,7 +664,7 @@ and expression_desc cxt ~(level : int) f x : cxt =
             Int32.to_string i
             (* check , js convention with ocaml lexical convention *)
         | Uint i -> Format.asprintf "%lu" i
-        | Bigint (sign, i) -> Format.asprintf "%sn" (Bigint_utils.to_string sign i)
+        | Bigint {positive; value} -> Format.asprintf "%sn" (Bigint_utils.to_string positive value)
       in
       let need_paren =
         if s.[0] = '-' then level > 13

jscomp/core/js_exp_make.ml

@@ -312,9 +312,9 @@ let obj_int_tag_literal : t =
 
 let int ?comment ?c i : t = { expression_desc = Number (Int { i; c }); comment }
 
-let bigint ?comment sign i : t = { expression_desc = Number (Bigint (sign, i)); comment}
+let bigint ?comment sign i : t = { expression_desc = Number (Bigint {positive=sign; value=i}); comment}
 
-let zero_bigint_literal : t = {expression_desc = Number (Bigint (true, "0")); comment = None}
+let zero_bigint_literal : t = {expression_desc = Number (Bigint {positive=true; value="0"}); comment = None}
 
 let small_int i : t =
   match i with
@@ -808,9 +808,7 @@ let tag_type = function
   | Int i -> small_int i
   | Float f -> float f
   | Bigint i -> 
-    let open Bigint_utils in
-    let sign, i = i |> remove_leading_sign in
-    let i = remove_leading_zeros i in
+    let sign, i = Bigint_utils.parse_bigint i in
     bigint sign i
   | Bool b -> bool b
   | Null -> nil

jscomp/core/js_op.ml

@@ -126,11 +126,13 @@ type 'a access = Getter | Setter
 (* literal char *)
 type float_lit = { f : string } [@@unboxed]
 
+type bigint_lit = { positive: bool; value: string }
+
 type number =
   | Float of float_lit
   | Int of { i : int32; c : int option }
   | Uint of int32
-  | Bigint of bool * string
+  | Bigint of bigint_lit
 
 (* becareful when constant folding +/-,
    since we treat it as js nativeint, bitwise operators:

jscomp/core/lam.ml

@@ -506,7 +506,7 @@ let prim ~primitive:(prim : Lam_primitive.t) ~args loc : t =
           (* FIXME: could raise? *)
           Lift.bool
             (Lam_compat.cmp_float cmp (float_of_string a) (float_of_string b))
-      | Pbigintcomp cmp, Const_bigint (_, a), Const_bigint (_, b) -> default ()
+      | Pbigintcomp cmp, Const_bigint _, Const_bigint _ -> default ()
       | Pintcomp ((Ceq | Cneq) as op), Const_pointer a, Const_pointer b ->
           Lift.bool
             (match op with

jscomp/frontend/external_ffi_types.ml

@@ -301,8 +301,7 @@ let inline_int64_primitive (i : int64) : string list =
   [""; to_string (Ffi_inline_const (Const_int64 i))]
 
 let inline_bigint_primitive (i : string) : string list =
-  let sign, i = i |> Bigint_utils.remove_leading_sign in
-  let i = Bigint_utils.remove_leading_zeros i in
+  let sign, i = Bigint_utils.parse_bigint i in
   [""; to_string (Ffi_inline_const (Const_bigint (sign, i)))]
 
 let inline_float_primitive (i : string) : string list =

jscomp/ml/bigint_utils.ml

@@ -8,7 +8,7 @@ let remove_leading_sign str : bool * string =
   if len = 0 then (false, str)
   else
     if is_neg str || is_pos str then (not (is_neg str), String.sub str 1 (len -1))
-    else (not (is_neg str), str)
+    else (true, str)
 
 (* 
   Removes leading zeros from the string only if the first non-zero character
@@ -48,7 +48,11 @@ let remove_leading_zeros str =
   let processed_str = aux str in
   if starts_with_minus then "-" ^ processed_str else processed_str
 
-let is_numeric s =
+let parse_bigint s =
+  let sign, i = remove_leading_sign s in
+  (sign, remove_leading_zeros i)
+
+let is_valid s =
   let len = String.length s in
   if len = 0 then false
   else

jscomp/ml/bigint_utils.mli

@@ -3,5 +3,6 @@ val is_pos: string -> bool
 val to_string: bool -> string -> string
 val remove_leading_sign : string -> bool * string
 val remove_leading_zeros : string -> string
-val is_numeric : string -> bool
+val parse_bigint: string -> bool * string
+val is_valid : string -> bool
 val compare : bool * string -> bool * string -> int

jscomp/ml/parmatch.ml

@@ -1107,7 +1107,7 @@ let build_other ext env : Typedtree.pattern = match env with
 | ({pat_desc=(Tpat_constant (Const_bigint _))} as p,_) :: _ ->
     build_other_constant
       (function Tpat_constant(Const_bigint (sign, i)) -> String.length (Bigint_utils.to_string sign i) | _ -> assert false)
-      (function i -> Tpat_constant(Const_bigint (true, (String.make i '*'))))
+      (function i -> Tpat_constant(Const_bigint (true, (string_of_int i))))
       0 succ p env
 | ({pat_desc=(Tpat_constant (Const_string _))} as p,_) :: _ ->
     build_other_constant

jscomp/ml/typecore.ml

@@ -260,8 +260,7 @@ let constant : Parsetree.constant -> (Asttypes.constant, error) result =
        with Failure _ -> Error (Literal_overflow "int64")
      end
   | Pconst_integer (i,Some 'n') ->
-    let sign, i = i |> Bigint_utils.remove_leading_sign in
-    let i = Bigint_utils.remove_leading_zeros i in
+    let sign, i = Bigint_utils.parse_bigint i in
     Ok (Const_bigint (sign, i))
   | Pconst_integer (i,Some c) -> Error (Unknown_literal (i, c))
   | Pconst_char c -> Ok (Const_char c)

jscomp/syntax/src/res_core.ml

@@ -813,10 +813,10 @@ let parseConstant p =
     match p.Parser.token with
     | Int {i; suffix} ->
       (* Only decimal literal is allowed for bigint *)
-      if suffix = Some 'n' && not (Bigint_utils.is_numeric i) then
+      if suffix = Some 'n' && not (Bigint_utils.is_valid i) then
         Parser.err p
           (Diagnostics.message
-             "Invalid decimal literal. Only decimal literal is allowed for \
+             "Invalid bigint literal. Only decimal literal is allowed for \
               bigint.");
       let intTxt = if isNegative then "-" ^ i else i in
       Parsetree.Pconst_integer (intTxt, suffix)