emit str

Author: cristianoc

jscomp/core/j.ml

@@ -147,14 +147,13 @@ and expression_desc =
      it will be true when it's a method
      The last pararemter [true] return unit
   *)
-  | Str of bool * string
-  (* A string is UTF-8 encoded, the string may contain
+  | Str of bool * string * bool
+  (* A string is UTF-8 encoded, and may contain
      escape sequences.
-     The first argument is used to mark it is non-pure, please
-     don't optimize it, since it does have side effec,
-     examples like "use asm;" and our compiler may generate "error;..."
-     which is better to leave it alone
-     The last argument is passed from as `j` from `{j||j}`
+     First argument: used to mark it as non-pure.
+     Please treat it carefully as it affects optimization.
+     Second argument: the string "j" in `{j||j}`.
+     The last argument: whether it should be escaped.
   *)
   | Unicode of string
   (* It is escaped string, print delimited by '"'*)

jscomp/core/js_analyzer.ml

@@ -90,7 +90,7 @@ let rec no_side_effect_expression_desc (x : J.expression_desc) =
   | String_index (a, b) | Array_index (a, b) ->
       no_side_effect a && no_side_effect b
   | Is_null_or_undefined b -> no_side_effect b
-  | Str (b, _) -> b
+  | Str (b, _, _) -> b
   | Array (xs, _mutable_flag) | Caml_block (xs, _mutable_flag, _, _) ->
       (* create [immutable] block,
           does not really mean that this opreation itself is [pure].
@@ -181,8 +181,8 @@ let rec eq_expression ({ expression_desc = x0 } : J.expression)
       | Bin (op1, a1, b1) ->
           op0 = op1 && eq_expression a0 a1 && eq_expression b0 b1
       | _ -> false)
-  | Str (a0, b0) -> (
-      match y0 with Str (a1, b1) -> a0 = a1 && b0 = b1 | _ -> false)
+  | Str (a0, b0, c0) -> (
+      match y0 with Str (a1, b1, c1) -> a0 = a1 && b0 = b1 && c0 = c1 | _ -> false)
   | Static_index (e0, p0, off0) -> (
       match y0 with
       | Static_index (e1, p1, off1) ->

jscomp/core/js_dump.ml

@@ -591,7 +591,7 @@ and expression_desc cxt ~(level : int) f x : cxt =
       P.string f s;
       P.string f "\"";
       cxt
-  | Str (_, s) ->
+  | Str (_, s, _) ->
       (*TODO --
          when utf8-> it will not escape '\\' which is definitely not we want
       *)

jscomp/core/js_dump_string.ml

@@ -101,6 +101,14 @@ let escape_to_string s =
   escape_to_buffer buf s;
   Ext_buffer.contents buf
 
+(*
+let pp_string ?(escape=true) f s =
+  if escape then
+    P.string f (escape_to_string s)
+  else
+    P.string f ("\"" ^ s ^ "\"")
+   
+*)
 let pp_string f s = P.string f (escape_to_string s)
 (* let _best_string_quote s =
    let simple = ref 0 in

jscomp/core/js_dump_string.mli

@@ -27,4 +27,5 @@
 *)
 val escape_to_string : string -> string
 
+(* val pp_string : ?escape:bool -> Ext_pp.t -> string -> unit *)
 val pp_string : Ext_pp.t -> string -> unit

jscomp/core/js_exp_make.ml

@@ -125,8 +125,8 @@ let pure_runtime_call module_name fn_name args =
 
 let runtime_ref module_name fn_name = runtime_var_dot module_name fn_name
 
-let str ?(pure = true) ?comment s : t =
-  { expression_desc = Str (pure, s); comment }
+let str ?(pure = true) ?comment ?(escape=true) s : t =
+  { expression_desc = Str (pure, s, escape); comment }
 
 let unicode ?comment s : t = { expression_desc = Unicode s; comment }
 
@@ -398,7 +398,7 @@ let extension_access (e : t) name (pos : int32) : t =
 
 let string_index ?comment (e0 : t) (e1 : t) : t =
   match (e0.expression_desc, e1.expression_desc) with
-  | Str (_, s), Number (Int { i; _ }) ->
+  | Str (_, s, _), Number (Int { i; _ }) ->
       (* Don't optimize {j||j} *)
       let i = Int32.to_int i in
       if i >= 0 && i < String.length s then
@@ -477,7 +477,7 @@ let array_length ?comment (e : t) : t =
 
 let string_length ?comment (e : t) : t =
   match e.expression_desc with
-  | Str (_, v) -> int ?comment (Int32.of_int (String.length v))
+  | Str (_, v, _) -> int ?comment (Int32.of_int (String.length v))
   (* No optimization for {j||j}*)
   | _ -> { expression_desc = Length (e, String); comment }
 
@@ -502,14 +502,14 @@ let function_length ?comment (e : t) : t =
 
 let rec string_append ?comment (e : t) (el : t) : t =
   match (e.expression_desc, el.expression_desc) with
-  | Str (_, a), String_append ({ expression_desc = Str (_, b) }, c) ->
+  | Str (_, a, _), String_append ({ expression_desc = Str (_, b, _) }, c) ->
       string_append ?comment (str (a ^ b)) c
-  | String_append (c, { expression_desc = Str (_, b) }), Str (_, a) ->
+  | String_append (c, { expression_desc = Str (_, b, _) }), Str (_, a, _) ->
       string_append ?comment c (str (b ^ a))
-  | ( String_append (a, { expression_desc = Str (_, b) }),
-      String_append ({ expression_desc = Str (_, c) }, d) ) ->
+  | ( String_append (a, { expression_desc = Str (_, b, _) }),
+      String_append ({ expression_desc = Str (_, c, _) }, d) ) ->
       string_append ?comment (string_append a (str (b ^ c))) d
-  | Str (_, a), Str (_, b) -> str ?comment (a ^ b)
+  | Str (_, a, _), Str (_, b, _) -> str ?comment (a ^ b)
   | _, _ -> { comment; expression_desc = String_append (e, el) }
 
 let obj ?comment properties : t =
@@ -548,7 +548,7 @@ let rec triple_equal ?comment (e0 : t) (e1 : t) : t =
       (Null | Undefined) )
     when no_side_effect e0 ->
       false_
-  | Str (_, x), Str (_, y) ->
+  | Str (_, x, _), Str (_, y, _) ->
       (* CF*)
       bool (Ext_string.equal x y)
   | Number (Int { i = i0; _ }), Number (Int { i = i1; _ }) -> bool (i0 = i1)
@@ -726,7 +726,7 @@ let int_equal = float_equal
 
 let string_equal ?comment (e0 : t) (e1 : t) : t =
   match (e0.expression_desc, e1.expression_desc) with
-  | Str (_, a0), Str (_, b0) -> bool (Ext_string.equal a0 b0)
+  | Str (_, a0, _), Str (_, b0, _) -> bool (Ext_string.equal a0 b0)
   | Unicode a0, Unicode b0 -> bool (Ext_string.equal a0 b0)
   | _, _ -> { expression_desc = Bin (EqEqEq, e0, e1); comment }
 
@@ -810,7 +810,7 @@ let uint32 ?comment n : J.expression =
 
 let string_comp (cmp : J.binop) ?comment (e0 : t) (e1 : t) =
   match (e0.expression_desc, e1.expression_desc) with
-  | Str (_, a0), Str (_, b0) -> (
+  | Str (_, a0, _), Str (_, b0, _) -> (
       match cmp with
       | EqEqEq -> bool (a0 = b0)
       | NotEqEq -> bool (a0 <> b0)

jscomp/core/js_exp_make.mli

@@ -82,7 +82,7 @@ val pure_runtime_call :
 
 val runtime_ref : string -> string -> t
 
-val str : ?pure:bool -> ?comment:string -> string -> t
+val str : ?pure:bool -> ?comment:string -> ?escape:bool -> string -> t
 
 val unicode : ?comment:string -> string -> t
 

jscomp/core/js_of_lam_variant.ml

@@ -32,9 +32,9 @@ let eval (arg : J.expression) (dispatches : (string * string) list) : E.t =
   if arg == E.undefined then E.undefined
   else
     match arg.expression_desc with
-    | Str (_, s) ->
+    | Str (_, s, _) ->
         let s = Ext_list.assoc_by_string dispatches s None in
-        E.str s
+        E.str (* ~escape:false *) s
     | _ ->
         E.of_block
           [
@@ -63,7 +63,7 @@ let eval (arg : J.expression) (dispatches : (string * string) list) : E.t =
 let eval_as_event (arg : J.expression)
     (dispatches : (string * string) list option) =
   match arg.expression_desc with
-  | Caml_block ([ { expression_desc = Str (_, s) }; cb ], _, _, Blk_poly_var _)
+  | Caml_block ([ { expression_desc = Str (_, s, _) }; cb ], _, _, Blk_poly_var _)
     when Js_analyzer.no_side_effect_expression cb ->
       let v =
         match dispatches with
@@ -101,7 +101,7 @@ let eval_as_int (arg : J.expression) (dispatches : (string * int) list) : E.t =
   if arg == E.undefined then E.undefined
   else
     match arg.expression_desc with
-    | Str (_, i) ->
+    | Str (_, i, _) ->
         E.int (Int32.of_int (Ext_list.assoc_by_string dispatches i None))
     | _ ->
         E.of_block

jscomp/core/js_stmt_make.ml

@@ -131,7 +131,7 @@ let string_switch ?(comment : string option)
     ?(declaration : (J.property * Ident.t) option) ?(default : J.block option)
     (e : J.expression) (clauses : (string * J.case_clause) list) : t =
   match e.expression_desc with
-  | Str (_, s) -> (
+  | Str (_, s, _) -> (
       let continuation =
         match
           Ext_list.find_opt clauses (fun (switch_case, x) ->

jscomp/frontend/ast_derive_js_mapper.ml

@@ -282,7 +282,7 @@ let init () =
                                  PStr
                                    [
                                      Str.eval
-                                       (Exp.constant (Const.string revData));
+                                       (Exp.constant (Const.string revData  (* XXX *)));
                                    ] )
                             else expMap);
                           toJsBody