Avoid sets, maps of simple expressions

A `Name.Set.t` or `'a Name.Map.t` is a fine thing, but a `Simple.Set.t`
or `'a Simple.Map.t` is much sketchier, since whether we want to treat
two simples that differ only in `Rec_info.t` as equivalent depends on
context. Fortunately, we usually just need a set or map of names. The
one place where this gets tricky is in the uses of `Aliases.get_alias`,
so there's now `Aliases.Alias_set.t` to encapsulate the needed
operations.

Author: lukemaurer

middle_end/flambda/basic/kinded_parameter.ml

@@ -111,8 +111,6 @@ module List = struct
 
   let name_set t = Name.Set.of_list (List.map Name.var (vars t))
 
-  let simple_set t = Simple.Set.of_list (simples t)
-
   let rename t = List.map (fun t -> rename t) t
 
   let arity t = List.map (fun t -> Flambda_kind.With_subkind.kind (kind t)) t

middle_end/flambda/basic/kinded_parameter.mli

@@ -68,8 +68,6 @@ module List : sig
   (** As for [var_set] but returns a set of [Name]s. *)
   val name_set : t -> Name.Set.t
 
-  val simple_set : t -> Simple.Set.t
-
   val equal_vars : t -> Variable.t list -> bool
 
   val rename : t -> t

middle_end/flambda/simplify/common_subexpression_elimination.ml

@@ -117,7 +117,12 @@ end
 
 let cse_with_eligible_lhs ~typing_env_at_fork ~cse_at_each_use ~params prev_cse
       (extra_bindings: EPA.t) extra_equations =
-  let params = KP.List.simple_set params in
+  let params = KP.List.name_set params in
+  let is_param simple =
+    Simple.pattern_match simple
+      ~name:(fun name -> Name.Set.mem name params)
+      ~const:(fun _ -> false)
+  in
   List.fold_left cse_at_each_use ~init:EP.Map.empty
     ~f:(fun eligible (env_at_use, id, cse) ->
       let find_new_name =
@@ -184,15 +189,17 @@ let cse_with_eligible_lhs ~typing_env_at_fork ~cse_at_each_use ~params prev_cse
                  since they are defined in [env_at_fork].  However these
                  aren't bound at the use sites, so we must choose another
                  alias that is. *)
-              if not (Simple.Set.mem bound_to params) then Some bound_to
+              if not (is_param bound_to) then Some bound_to
               else
                 let aliases =
                   TE.aliases_of_simple env_at_use
                     ~min_name_mode:NM.normal bound_to
-                  |> Simple.Set.filter (fun simple ->
-                    not (Simple.Set.mem simple params))
+                  |> Aliases.Alias_set.filter ~f:(fun simple ->
+                    not (is_param simple))
                 in
-                Simple.Set.get_singleton aliases
+                (* CR lmaurer: This could be using
+                   [Aliases.Alias_set.find_best], I think? *)
+                Aliases.Alias_set.get_singleton aliases
             in
             match bound_to with
             | None -> eligible