comment unused code

Author: bobzhang

jscomp/core/lam.mli

@@ -117,8 +117,8 @@ val switch : t -> lambda_switch -> t
 (** constant folding*)
 val stringswitch : t -> (string * t) list -> t option -> t 
 
-val true_ : t 
-val false_ : t 
+(* val true_ : t  *)
+(* val false_ : t  *)
 val unit : t 
 
 (** convert [l || r] to [if l then true else r]*)

jscomp/syntax/ast_attributes.ml

@@ -179,7 +179,7 @@ let process_derive_type (attrs : t) : derive_attr * t =
         st, attr::acc
     ) 
 
-let iter_process_derive_type (attrs : t) =
+(* let iter_process_derive_type (attrs : t) =
   let st = ref {explict_nonrec = false; bs_deriving = None } in
   Ext_list.iter attrs
     (fun ({txt ; loc}, payload  as attr)  ->
@@ -203,7 +203,7 @@ let iter_process_derive_type (attrs : t) =
       (* non bs attribute, no need to mark its use *)
       | _ -> ()
     ) ;
-  !st
+  !st *)
 
 
 (* duplicated [bs.uncurry] [bs.string] not allowed,
@@ -345,23 +345,17 @@ let iter_process_bs_string_or_int_as (attrs : Parsetree.attributes) =
   !st
 
 let locg = Location.none
-let bs : attr
-  =  {txt = "bs" ; loc = locg}, Ast_payload.empty
+(* let bs : attr
+  =  {txt = "bs" ; loc = locg}, Ast_payload.empty *)
 
 let is_bs (attr : attr) =
   match attr with
   | {Location.txt = "bs"; _}, _ -> true
   | _ -> false
 
-let is_optional (attr : attr) =
-  match attr with
-  | {Location.txt = "bs.optional"; _}, _ -> true
-  | _ -> false
 
-let is_bs_as (attr : attr) =
-  match attr with
-  | {Location.txt = "bs.as"; _}, _ -> true
-  | _ -> false
+
+
 
 let bs_get : attr
   =  {txt = "bs.get"; loc = locg}, Ast_payload.empty
@@ -396,12 +390,3 @@ let bs_return_undefined : attr
            },[])
       ; pstr_loc = locg}]
 
-let deprecated s : attr =       
-  {txt = "ocaml.deprecated"; loc = locg },
-  PStr
-    [
-      {pstr_desc =
-         Pstr_eval (
-           Ast_compatible.const_exp_string ~loc:locg s, 
-           [])
-      ; pstr_loc = locg}]

jscomp/syntax/ast_attributes.mli

@@ -93,14 +93,14 @@ val iter_process_bs_string_or_int_as :
 val process_derive_type :
   t -> derive_attr * t
 
-val iter_process_derive_type :
+(* val iter_process_derive_type :
   t -> derive_attr
 
 
-val bs : attr
+val bs : attr *)
 val is_bs : attr -> bool
-val is_optional : attr -> bool
-val is_bs_as : attr -> bool
+(* val is_optional : attr -> bool
+val is_bs_as : attr -> bool *)
 
 
 
@@ -109,4 +109,4 @@ val bs_get_arity : attr
 val bs_set : attr
 val bs_return_undefined : attr
 
-val deprecated : string -> attr
+(* val deprecated : string -> attr *)

jscomp/syntax/ast_comb.ml

@@ -31,11 +31,11 @@ open Ast_helper
   Ast_compatible.fun_ ?loc ?attrs  pat body *)
 
 
-let discard_exp_as_unit loc e = 
+(* let discard_exp_as_unit loc e = 
   Ast_compatible.apply_simple ~loc     
     (Exp.ident ~loc {txt = Ast_literal.Lid.ignore_id; loc})
     [Exp.constraint_ ~loc e 
-       (Ast_literal.type_unit ~loc ())]
+       (Ast_literal.type_unit ~loc ())] *)
 
 
 let tuple_type_pair ?loc kind arity = 

jscomp/syntax/ast_comb.mli

@@ -31,8 +31,8 @@
    we can use [unit] value (though very little chance) 
    sometimes
 *)
-val discard_exp_as_unit : 
-  Location.t -> Parsetree.expression -> Parsetree.expression
+(* val discard_exp_as_unit : 
+  Location.t -> Parsetree.expression -> Parsetree.expression *)
 
 
 val tuple_type_pair : 

jscomp/syntax/ast_compatible.ml

@@ -105,10 +105,10 @@ let fun_
     pexp_desc = Pexp_fun(Nolabel,None, pat, exp)
   }
 
-let opt_label s =
-  Asttypes.Optional s
+(* let opt_label s =
+  Asttypes.Optional s *)
 
-let label_fun
+(* let label_fun
   ?(loc = default_loc)
   ?(attrs = [])
   ~label
@@ -118,7 +118,7 @@ let label_fun
     pexp_loc = loc;
     pexp_attributes = attrs;
     pexp_desc = Pexp_fun(label, None, pat, exp)
-  }
+  } *)
 
 
 
@@ -204,13 +204,13 @@ let rec_type_str ?(loc=default_loc)  tds : structure_item =
       tds)
   }
 
-let nonrec_type_str ?(loc=default_loc)  tds : structure_item = 
+(* let nonrec_type_str ?(loc=default_loc)  tds : structure_item = 
   {
     pstr_loc = loc;
     pstr_desc = Pstr_type ( 
       Nonrecursive,
       tds)
-  }  
+  }   *)
 
 let rec_type_sig ?(loc=default_loc)  tds : signature_item = 
   {
@@ -221,22 +221,22 @@ let rec_type_sig ?(loc=default_loc)  tds : signature_item =
   }
 
 (* FIXME: need address migration of `[@nonrec]` attributes in older ocaml *)  
-let nonrec_type_sig ?(loc=default_loc)  tds : signature_item = 
+(* let nonrec_type_sig ?(loc=default_loc)  tds : signature_item = 
   {
     psig_loc = loc;
     psig_desc = Psig_type ( 
       Nonrecursive,
       tds)
-  }  
+  }   *)
 
 
 let const_exp_int_list_as_array xs = 
   Ast_helper.Exp.array 
   (Ext_list.map  xs (fun x -> const_exp_int x ))  
 
-let const_exp_string_list_as_array xs =   
+(* let const_exp_string_list_as_array xs =   
   Ast_helper.Exp.array 
-  (Ext_list.map xs (fun x -> const_exp_string x ) )  
+  (Ext_list.map xs (fun x -> const_exp_string x ) )   *)
 
 type param_type = 
   {label : Asttypes.arg_label ;

jscomp/syntax/ast_compatible.mli

@@ -53,9 +53,9 @@ val const_exp_int_list_as_array:
   int list -> 
   expression 
 
-val const_exp_string_list_as_array:  
+(* val const_exp_string_list_as_array:  
   string list -> 
-  expression 
+  expression  *)
 
 
 val apply_simple:
@@ -109,15 +109,15 @@ val fun_ :
   expression -> 
   expression
 
-val opt_label : string -> Asttypes.arg_label
+(* val opt_label : string -> Asttypes.arg_label *)
 
-val label_fun :
+(* val label_fun :
   ?loc:Location.t ->
   ?attrs:attrs ->
   label:Asttypes.arg_label ->
   pattern ->
   expression ->
-  expression
+  expression *)
 
 val arrow :
   ?loc:Location.t -> 
@@ -150,20 +150,20 @@ val object_:
   core_type  
 
 
-val nonrec_type_str:  
+(* val nonrec_type_str:  
   ?loc:loc -> 
   type_declaration list -> 
-  structure_item
+  structure_item *)
 
 val rec_type_str:  
   ?loc:loc -> 
   type_declaration list -> 
   structure_item
 
-val nonrec_type_sig:  
+(* val nonrec_type_sig:  
   ?loc:loc -> 
   type_declaration list -> 
-  signature_item 
+  signature_item  *)
 
 val rec_type_sig:  
   ?loc:loc -> 

jscomp/syntax/ast_core_type.ml

@@ -47,7 +47,7 @@ let is_any (ty : t) =
 
 open Ast_helper
 
-let replace_result (ty : t) (result : t) : t =
+(* let replace_result (ty : t) (result : t) : t =
   let rec aux (ty : Parsetree.core_type) =
     match ty with
     | { ptyp_desc =
@@ -56,17 +56,17 @@ let replace_result (ty : t) (result : t) : t =
     | {ptyp_desc = Ptyp_poly(fs,ty)}
       ->  {ty with ptyp_desc = Ptyp_poly(fs, aux ty)}
     | _ -> result in
-  aux ty
+  aux ty *)
 
 let is_unit (ty : t ) =
   match ty.ptyp_desc with
   | Ptyp_constr({txt =Lident "unit"}, []) -> true
   | _ -> false
 
-let is_array (ty : t) =
+(* let is_array (ty : t) =
   match ty.ptyp_desc with
   | Ptyp_constr({txt =Lident "array"}, [_]) -> true
-  | _ -> false
+  | _ -> false *)
 
 let is_user_option (ty : t) =
   match ty.ptyp_desc with
@@ -76,15 +76,15 @@ let is_user_option (ty : t) =
     [_]) -> true
   | _ -> false
 
-let is_user_bool (ty : t) =
+(* let is_user_bool (ty : t) =
   match ty.ptyp_desc with
   | Ptyp_constr({txt = Lident "bool"},[]) -> true
-  | _ -> false
+  | _ -> false *)
 
-let is_user_int (ty : t) =
+(* let is_user_int (ty : t) =
   match ty.ptyp_desc with
   | Ptyp_constr({txt = Lident "int"},[]) -> true
-  | _ -> false
+  | _ -> false *)
 
 
 

jscomp/syntax/ast_core_type.mli

@@ -29,12 +29,12 @@ type t = Parsetree.core_type
 
 val lift_option_type : t -> t
 val is_any : t -> bool
-val replace_result : t -> t -> t
+(* val replace_result : t -> t -> t *)
 
 (* val opt_arrow: Location.t -> string -> t -> t -> t *)
 
 val is_unit : t -> bool
-val is_array : t -> bool
+(* val is_array : t -> bool *)
 
 
 (** return a function type
@@ -52,9 +52,9 @@ val make_obj :
 
 val is_user_option : t -> bool
 
-val is_user_bool : t -> bool
+(* val is_user_bool : t -> bool
 
-val is_user_int : t -> bool
+val is_user_int : t -> bool *)
 
 
 

jscomp/syntax/ast_derive_util.ml

@@ -52,7 +52,7 @@ let new_type_of_type_declaration
     )
 
 
-let mk_fun ~loc (typ : Parsetree.core_type) 
+(* let mk_fun ~loc (typ : Parsetree.core_type) 
     (value : string) body
   : Parsetree.expression = 
   Ast_compatible.fun_
@@ -71,7 +71,7 @@ let destruct_label_declarations ~loc
         Exp.field (Exp.ident {txt = Lident arg_name ; loc}) 
           {txt = Lident txt ; loc}) :: core_type_exps),
       txt :: labels 
-    ) 
+    )  *)
 
 let notApplicable 
   loc derivingName =