change analysis_input to be a list of variables (not a set)

Author: o-

analysis.ml

@@ -192,11 +192,10 @@ let as_var_set (formals : formal_parameter list) =
   VarSet.of_list (as_var_list formals)
 
 let as_var_map formals =
-  let formals = VarSet.elements formals in
   VariableMap.initial formals
 
 let as_analysis_input (func:afunction) (version:version) =
-  { formals = as_var_set func.formals; instrs = version.instrs }
+  { formals = as_var_list func.formals; instrs = version.instrs }
 
 (* returns a 'pc -> pc set' computing reaching definitions *)
 let reaching {formals; instrs} : pc -> PosSet.t =
@@ -302,7 +301,7 @@ let required_vars ({instrs} as inp : analysis_input) : pc -> variable list =
 
 let aliased ({formals; instrs} : analysis_input) : pc -> VarSet.t =
   let ref_param params x = x :: params in
-  let mut_formals = List.fold_left ref_param [] (VarSet.elements formals) in
+  let mut_formals = List.fold_left ref_param [] formals in
   fun _ -> VarSet.of_list mut_formals
 
 module Expression = struct

scope.ml

@@ -57,7 +57,7 @@ let infer ({formals; instrs} : analysis_input) : inferred_scope array =
       let final_info = List.fold_left remove updated dropped in
       { sources = PcSet.singleton pc; info = final_info; }
     in
-    let initial = List.map (fun var -> (var, -1)) (VarSet.elements formals) in
+    let initial = List.map (fun var -> (var, -1)) formals in
     let initial_state = { sources = PcSet.empty; info = DeclSet.of_list initial; } in
     let res = Analysis.forward_analysis initial_state instrs merge update in
     fun pc -> (res pc).info in

transform_constantfold.ml

@@ -103,7 +103,7 @@ let const_fold : transform_instructions = fun {formals; instrs} ->
 
     let initial_state =
       let add_formal x st = VarMap.add x Unknown st in
-      VarSet.fold add_formal formals VarMap.empty
+      VarSet.fold add_formal (VarSet.of_list formals) VarMap.empty
     in
     Analysis.forward_analysis initial_state instrs merge update
   in

transform_inline.ml

@@ -2,16 +2,6 @@ open Instr
 open Edit
 open Types
 
-(* Unlike `analysis_input`, this preserves the order of `formals`. This
-   facilitates matching the formals to the arguments passed at a callsite.*)
-type inlining_input = {
-  formals : variable list;
-  instrs : instructions;
-}
-
-let as_inlining_input (func : afunction) : inlining_input =
-  { formals = Analysis.as_var_list func.formals; instrs = (active_version func).instrs }
-
 type inlining_candidate = {
   pos : pc;
   target : afunction;
@@ -22,6 +12,9 @@ type inlining_candidate = {
 }
 and inlining_site = inlining_candidate list
 
+let as_inlining_input (func : afunction) =
+  { formals = Analysis.as_var_list func.formals; instrs = (active_version func).instrs }
+
 
 (* FUNCTION INLINING *)
 (* Given a program, inline the functions in it to the maximum possible extent.
@@ -66,7 +59,7 @@ let inline ({main; functions} as orig_prog : program) : program option =
       in
       loop 0 []
     in
-    let scope = Scope.infer {formals = VarSet.of_list callee.formals;
+    let scope = Scope.infer {formals = callee.formals;
                              instrs = callee.instrs;}
     in
     let returns = extract_returns instrs in

transform_utils.ml

@@ -57,7 +57,7 @@ let fix_scope : transform_instructions = fun {formals; instrs} ->
     let dropped = Instr.dropped_vars instr in
     VarSet.diff updated dropped
   in
-  let initial_state = formals in
+  let initial_state = VarSet.of_list formals in
   let scope = Analysis.forward_analysis initial_state instrs merge update in
   let succs = Analysis.successors instrs in
   let transform pc =

types.ml

@@ -1,7 +1,7 @@
 open Instr
 
 type analysis_input = {
-  formals : VarSet.t;
+  formals : variable list;
   instrs : instructions;
 }