Renamed Wa_ast into Wasm_ast

Author: vouillon

compiler/lib-wasm/wa_code_generation.ml

@@ -18,7 +18,7 @@
 
 open! Stdlib
 open Code
-module W = Wa_ast
+module W = Wasm_ast
 
 (*
 LLVM type checker does not work well. It does not handle 'br', and
@@ -41,9 +41,9 @@ type context =
   ; mutable data_segments : string Var.Map.t
   ; mutable constant_globals : constant_global Var.Map.t
   ; mutable other_fields : W.module_field list
-  ; mutable imports : (Var.t * Wa_ast.import_desc) StringMap.t StringMap.t
+  ; mutable imports : (Var.t * Wasm_ast.import_desc) StringMap.t StringMap.t
   ; type_names : (string, Var.t) Hashtbl.t
-  ; types : (Var.t, Wa_ast.type_field) Hashtbl.t
+  ; types : (Var.t, Wasm_ast.type_field) Hashtbl.t
   ; mutable closure_envs : Var.t Var.Map.t
         (** GC: mapping of recursive functions to their shared environment *)
   ; mutable apply_funs : Var.t IntMap.t
@@ -100,7 +100,7 @@ and state =
 
 and 'a t = state -> 'a * state
 
-type expression = Wa_ast.expression t
+type expression = Wasm_ast.expression t
 
 let ( let* ) (type a b) (e : a t) (f : a -> b t) : b t =
  fun st ->
@@ -130,9 +130,9 @@ let register_constant x e st =
   (), st
 
 type type_def =
-  { supertype : Wa_ast.var option
+  { supertype : Wasm_ast.var option
   ; final : bool
-  ; typ : Wa_ast.str_type
+  ; typ : Wasm_ast.str_type
   }
 
 let register_type nm gen_typ st =
@@ -141,7 +141,7 @@ let register_type nm gen_typ st =
   ( (try Hashtbl.find context.type_names nm
      with Not_found ->
        let name = Var.fresh_n nm in
-       let type_field = { Wa_ast.name; typ; supertype; final } in
+       let type_field = { Wasm_ast.name; typ; supertype; final } in
        context.other_fields <- Type [ type_field ] :: context.other_fields;
        Hashtbl.add context.type_names nm name;
        Hashtbl.add context.types name type_field;

compiler/lib-wasm/wa_code_generation.mli

@@ -21,13 +21,13 @@ open Stdlib
 type constant_global
 
 type context =
-  { constants : (Code.Var.t, Wa_ast.expression) Hashtbl.t
+  { constants : (Code.Var.t, Wasm_ast.expression) Hashtbl.t
   ; mutable data_segments : string Code.Var.Map.t
   ; mutable constant_globals : constant_global Code.Var.Map.t
-  ; mutable other_fields : Wa_ast.module_field list
-  ; mutable imports : (Code.Var.t * Wa_ast.import_desc) StringMap.t StringMap.t
+  ; mutable other_fields : Wasm_ast.module_field list
+  ; mutable imports : (Code.Var.t * Wasm_ast.import_desc) StringMap.t StringMap.t
   ; type_names : (string, Code.Var.t) Hashtbl.t
-  ; types : (Code.Var.t, Wa_ast.type_field) Hashtbl.t
+  ; types : (Code.Var.t, Wasm_ast.type_field) Hashtbl.t
   ; mutable closure_envs : Code.Var.t Code.Var.Map.t
         (** GC: mapping of recursive functions to their shared environment *)
   ; mutable apply_funs : Code.Var.t Stdlib.IntMap.t
@@ -36,31 +36,31 @@ type context =
   ; mutable cps_curry_funs : Code.Var.t Stdlib.IntMap.t
   ; mutable dummy_funs : Code.Var.t Stdlib.IntMap.t
   ; mutable cps_dummy_funs : Code.Var.t Stdlib.IntMap.t
-  ; mutable init_code : Wa_ast.instruction list
+  ; mutable init_code : Wasm_ast.instruction list
   ; mutable string_count : int
   ; mutable strings : string list
   ; mutable string_index : int StringMap.t
   ; mutable fragments : Javascript.expression StringMap.t
   ; mutable globalized_variables : Code.Var.Set.t
-  ; value_type : Wa_ast.value_type
+  ; value_type : Wasm_ast.value_type
   ; mutable unit_name : string option
   }
 
-val make_context : value_type:Wa_ast.value_type -> context
+val make_context : value_type:Wasm_ast.value_type -> context
 
 type 'a t
 
-type expression = Wa_ast.expression t
+type expression = Wasm_ast.expression t
 
 val ( let* ) : 'a t -> ('a -> 'b t) -> 'b t
 
 val return : 'a -> 'a t
 
-val instr : Wa_ast.instruction -> unit t
+val instr : Wasm_ast.instruction -> unit t
 
 val seq : unit t -> expression -> expression
 
-val expression_list : ('a -> expression) -> 'a list -> Wa_ast.expression list t
+val expression_list : ('a -> expression) -> 'a list -> Wasm_ast.expression list t
 
 module Arith : sig
   val const : int32 -> expression
@@ -106,38 +106,42 @@ module Arith : sig
   val eqz : expression -> expression
 end
 
-val cast : ?nullable:bool -> Wa_ast.heap_type -> expression -> expression
+val cast : ?nullable:bool -> Wasm_ast.heap_type -> expression -> expression
 
-val load : Wa_ast.var -> expression
+val load : Wasm_ast.var -> expression
 
-val tee : ?typ:Wa_ast.value_type -> Wa_ast.var -> expression -> expression
+val tee : ?typ:Wasm_ast.value_type -> Wasm_ast.var -> expression -> expression
 
-val store : ?always:bool -> ?typ:Wa_ast.value_type -> Wa_ast.var -> expression -> unit t
+val store :
+  ?always:bool -> ?typ:Wasm_ast.value_type -> Wasm_ast.var -> expression -> unit t
 
-val assign : Wa_ast.var -> expression -> unit t
+val assign : Wasm_ast.var -> expression -> unit t
 
 val drop : expression -> unit t
 
 val push : expression -> unit t
 
-val loop : Wa_ast.func_type -> unit t -> unit t
+val loop : Wasm_ast.func_type -> unit t -> unit t
 
-val block : Wa_ast.func_type -> unit t -> unit t
+val block : Wasm_ast.func_type -> unit t -> unit t
 
-val block_expr : Wa_ast.func_type -> unit t -> expression
+val block_expr : Wasm_ast.func_type -> unit t -> expression
 
-val if_ : Wa_ast.func_type -> expression -> unit t -> unit t -> unit t
+val if_ : Wasm_ast.func_type -> expression -> unit t -> unit t -> unit t
 
 val try_expr :
-  Wa_ast.func_type -> unit t -> (Code.Var.t * int * Wa_ast.value_type) list -> expression
+     Wasm_ast.func_type
+  -> unit t
+  -> (Code.Var.t * int * Wasm_ast.value_type) list
+  -> expression
 
-val add_var : ?typ:Wa_ast.value_type -> Wa_ast.var -> Wa_ast.var t
+val add_var : ?typ:Wasm_ast.value_type -> Wasm_ast.var -> Wasm_ast.var t
 
-val define_var : Wa_ast.var -> expression -> unit t
+val define_var : Wasm_ast.var -> expression -> unit t
 
-val is_small_constant : Wa_ast.expression -> bool t
+val is_small_constant : Wasm_ast.expression -> bool t
 
-val get_i31_value : Wa_ast.var -> Wa_ast.var option t
+val get_i31_value : Wasm_ast.var -> Wasm_ast.var option t
 
 val event : Parse_info.t -> unit t
 
@@ -146,27 +150,27 @@ val no_event : unit t
 val hidden_location : Parse_info.t
 
 type type_def =
-  { supertype : Wa_ast.var option
+  { supertype : Wasm_ast.var option
   ; final : bool
-  ; typ : Wa_ast.str_type
+  ; typ : Wasm_ast.str_type
   }
 
-val register_type : string -> (unit -> type_def t) -> Wa_ast.var t
+val register_type : string -> (unit -> type_def t) -> Wasm_ast.var t
 
-val heap_type_sub : Wa_ast.heap_type -> Wa_ast.heap_type -> bool t
+val heap_type_sub : Wasm_ast.heap_type -> Wasm_ast.heap_type -> bool t
 
 val register_import :
-  ?import_module:string -> name:string -> Wa_ast.import_desc -> Wa_ast.var t
+  ?import_module:string -> name:string -> Wasm_ast.import_desc -> Wasm_ast.var t
 
 val register_global :
-     Wa_ast.var
+     Wasm_ast.var
   -> ?exported_name:string
   -> ?constant:bool
-  -> Wa_ast.global_type
-  -> Wa_ast.expression
+  -> Wasm_ast.global_type
+  -> Wasm_ast.expression
   -> unit t
 
-val get_global : Code.Var.t -> Wa_ast.expression option t
+val get_global : Code.Var.t -> Wasm_ast.expression option t
 
 val register_data_segment : Code.Var.t -> string -> unit t
 
@@ -198,4 +202,4 @@ val function_body :
      context:context
   -> param_names:Code.Var.t list
   -> body:unit t
-  -> (Wa_ast.var * Wa_ast.value_type) list * Wa_ast.instruction list
+  -> (Wasm_ast.var * Wasm_ast.value_type) list * Wasm_ast.instruction list

compiler/lib-wasm/wa_curry.ml

@@ -18,7 +18,7 @@
 
 open! Stdlib
 open Code
-module W = Wa_ast
+module W = Wasm_ast
 open Wa_code_generation
 
 module Make (Target : Wa_target_sig.S) = struct

compiler/lib-wasm/wa_gc_target.ml

@@ -17,10 +17,10 @@
  *)
 
 open! Stdlib
-module W = Wa_ast
+module W = Wasm_ast
 open Wa_code_generation
 
-type expression = Wa_ast.expression Wa_code_generation.t
+type expression = Wasm_ast.expression Wa_code_generation.t
 
 let include_closure_arity = false
 

compiler/lib-wasm/wa_generate.ml

@@ -18,7 +18,7 @@
 
 open! Stdlib
 open Code
-module W = Wa_ast
+module W = Wasm_ast
 open Wa_code_generation
 
 module Generate (Target : Wa_target_sig.S) = struct

compiler/lib-wasm/wa_generate.mli

@@ -28,9 +28,9 @@ val f :
   -> in_cps:Effects.in_cps
   -> deadcode_sentinal:Code.Var.t
   -> debug:Parse_bytecode.Debug.t
-  -> Wa_ast.var * (string list * (string * Javascript.expression) list)
+  -> Wasm_ast.var * (string list * (string * Javascript.expression) list)
 
-val add_start_function : context:Wa_code_generation.context -> Wa_ast.var -> unit
+val add_start_function : context:Wa_code_generation.context -> Wasm_ast.var -> unit
 
 val add_init_function : context:Wa_code_generation.context -> to_link:string list -> unit
 

compiler/lib-wasm/wa_initialize_locals.ml

@@ -33,7 +33,7 @@ let check_initialized ctx i =
 
 let rec scan_expression ctx e =
   match e with
-  | Wa_ast.Const _ | GlobalGet _ | Pop _ | RefFunc _ | RefNull _ -> ()
+  | Wasm_ast.Const _ | GlobalGet _ | Pop _ | RefFunc _ | RefNull _ -> ()
   | UnOp (_, e')
   | I32WrapI64 e'
   | I64ExtendI32 (_, e')
@@ -74,7 +74,7 @@ and scan_expressions ctx l = List.iter ~f:(fun e -> scan_expression ctx e) l
 
 and scan_instruction ctx i =
   match i with
-  | Wa_ast.Drop e
+  | Wasm_ast.Drop e
   | GlobalSet (_, e)
   | Br (_, Some e)
   | Br_if (_, e)
@@ -114,12 +114,12 @@ let f ~param_names ~locals instrs =
   List.iter ~f:(fun x -> mark_initialized ctx x) param_names;
   List.iter
     ~f:(fun (var, typ) ->
-      match (typ : Wa_ast.value_type) with
+      match (typ : Wasm_ast.value_type) with
       | I32 | I64 | F32 | F64 | Ref { nullable = true; _ } -> mark_initialized ctx var
       | Ref { nullable = false; _ } -> ())
     locals;
   scan_instructions ctx instrs;
   List.map
-    ~f:(fun i -> Wa_ast.LocalSet (i, RefI31 (Const (I32 0l))))
+    ~f:(fun i -> Wasm_ast.LocalSet (i, RefI31 (Const (I32 0l))))
     (Code.Var.Set.elements !(ctx.uninitialized))
   @ instrs

compiler/lib-wasm/wa_initialize_locals.mli

@@ -17,7 +17,7 @@
  *)
 
 val f :
-     param_names:Wa_ast.var list
-  -> locals:(Wa_ast.var * Wa_ast.value_type) list
-  -> Wa_ast.instruction list
-  -> Wa_ast.instruction list
+     param_names:Wasm_ast.var list
+  -> locals:(Wasm_ast.var * Wasm_ast.value_type) list
+  -> Wasm_ast.instruction list
+  -> Wasm_ast.instruction list

compiler/lib-wasm/wa_tail_call.ml

@@ -20,21 +20,21 @@ open! Stdlib
 
 let get_return ~tail i =
   match i with
-  | Wa_ast.Return (Some (LocalGet y)) -> Some y
+  | Wasm_ast.Return (Some (LocalGet y)) -> Some y
   | Push (LocalGet y) when tail -> Some y
   | _ -> None
 
 let rewrite_tail_call ~y i =
   match i with
-  | Wa_ast.LocalSet (x, Call (symb, l)) when Code.Var.equal x y ->
-      Some (Wa_ast.Return_call (symb, l))
+  | Wasm_ast.LocalSet (x, Call (symb, l)) when Code.Var.equal x y ->
+      Some (Wasm_ast.Return_call (symb, l))
   | LocalSet (x, Call_ref (ty, e, l)) when Code.Var.equal x y ->
       Some (Return_call_ref (ty, e, l))
   | _ -> None
 
 let rec instruction ~tail i =
   match i with
-  | Wa_ast.Loop (ty, l) -> Wa_ast.Loop (ty, instructions ~tail l)
+  | Wasm_ast.Loop (ty, l) -> Wasm_ast.Loop (ty, instructions ~tail l)
   | Block (ty, l) -> Block (ty, instructions ~tail l)
   | If (ty, e, l1, l2) -> If (ty, e, instructions ~tail l1, instructions ~tail l2)
   | Return (Some (Call (symb, l))) -> Return_call (symb, l)

compiler/lib-wasm/wa_tail_call.mli

@@ -16,4 +16,4 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *)
 
-val f : Wa_ast.instruction list -> Wa_ast.instruction list
+val f : Wasm_ast.instruction list -> Wasm_ast.instruction list