Revert Reflection / dune rules changes

Signed-off-by: Nat Karmios <nat@karmios.com>

Author: NatKarmios

bin/print_rules.ml

@@ -222,40 +222,24 @@ let targets_repr =
 ;;
 
 let rule_context (rule : Dune_engine.Reflection.Rule.t) =
-  match
-    Option.bind rule.targets ~f:(fun ts ->
-      Path.Build.extract_build_context ts.Targets.Validated.root)
-  with
+  match Path.Build.extract_build_context rule.targets.Targets.Validated.root with
   | None -> None
   | Some (context, _) -> Some (Filename.to_string context)
 ;;
 
-let rule_loc ~with_locs (rule : Dune_engine.Reflection.Rule.t) =
-  if (not with_locs) || Loc.is_none rule.loc
-  then None
-  else (
-    let start = Loc.start rule.loc in
-    Some (sprintf "%s:%d" start.pos_fname start.pos_lnum))
-;;
-
-let rule_repr ~with_locs =
+let rule_repr =
   Repr.record
     "rule"
     [ Repr.field "deps" deps_repr ~get:(fun rule -> rule.Dune_engine.Reflection.Rule.deps)
-    ; Repr.field "targets" (Repr.option targets_repr) ~get:(fun rule ->
+    ; Repr.field "targets" targets_repr ~get:(fun rule ->
         rule.Dune_engine.Reflection.Rule.targets)
     ; Repr.field "context" (Repr.option Repr.string) ~get:rule_context
     ; Repr.field "action" action_repr ~get:(fun rule ->
         rule.Dune_engine.Reflection.Rule.action)
-    ; Repr.field
-        "aliases"
-        (Repr.option (Repr.list Alias_name.repr))
-        ~get:(fun rule -> rule.Dune_engine.Reflection.Rule.aliases)
-    ; Repr.field "loc" (Repr.option Repr.string) ~get:(rule_loc ~with_locs)
     ]
 ;;
 
-let rules_repr ~with_locs = Repr.list (rule_repr ~with_locs)
+let rules_repr = Repr.list rule_repr
 let deps_only_repr = Repr.list deps_repr
 
 let dep_sets_of_rules rules =
@@ -308,13 +292,10 @@ let print_json oc json =
   output_char oc '\n'
 ;;
 
-let print_rules_sexp ~with_locs ppf rules =
+let print_rules_sexp ppf rules =
   Syntax.prepare_formatter ppf;
   Format.pp_open_vbox ppf 0;
-  Format.pp_print_list
-    (fun ppf rule -> print_sexp_repr ppf (rule_repr ~with_locs) rule)
-    ppf
-    rules;
+  Format.pp_print_list (fun ppf rule -> print_sexp_repr ppf rule_repr rule) ppf rules;
   Format.pp_print_flush ppf ()
 ;;
 
@@ -356,15 +337,8 @@ let term =
       value
       & opt (enum Output_format.all) Output_format.Sexp
       & info [ "format" ] ~docv:"FORMAT" ~doc:(Some doc))
-  and+ with_locs =
-    Arg.(value & flag & info [ "with-locs" ] ~doc:(Some "Include locations of rules"))
   (* CR-someday Alizter: document this option *)
   and+ targets = Arg.(value & pos_all dep [] & Arg.info [] ~docv:"TARGET" ~doc:None) in
-  let targets =
-    match targets with
-    | [] -> [ Common.Builder.default_target builder ]
-    | _ :: _ -> targets
-  in
   let common, config = Common.init builder in
   let out = Option.map ~f:Path.of_string out in
   Scheduler_setup.go_with_rpc_server ~common ~config (fun () ->
@@ -383,10 +357,9 @@ let term =
       let print oc =
         let ppf = Format.formatter_of_out_channel oc in
         match format, deps_only with
-        | Output_format.Sexp, false -> print_rules_sexp ~with_locs ppf rules
+        | Output_format.Sexp, false -> print_rules_sexp ppf rules
         | Output_format.Sexp, true -> print_rule_deps_only_sexp ppf rules
-        | Json, false ->
-          print_json oc (Json.of_dyn (dyn_of_repr (rules_repr ~with_locs) rules))
+        | Json, false -> print_json oc (Json.of_dyn (dyn_of_repr rules_repr rules))
         | Json, true ->
           print_json
             oc

doc/changes/changed/15581.md

@@ -1,73 +1,62 @@
 open Import
 module Non_evaluated_rule = Rule
-module Anon_rule = Rule.Anonymous_action.Rule
 open Memo.O
 
 module Rule = struct
   type t =
     { id : Rule.Id.t
     ; deps : Dep.Set.t
     ; expanded_deps : Path.Set.t
-    ; targets : Targets.Validated.t option
+    ; targets : Targets.Validated.t
     ; action : Action.t
-    ; aliases : Alias_name.t list option
-    ; loc : Loc.t
     }
 end
 
 module Rule_top_closure = Top_closure.Make (Non_evaluated_rule.Id.Set) (Memo)
 
 module rec Expand : sig
-  type expanded := Path.Set.t * Anon_rule.Set.t
-
-  val alias : Alias.t -> expanded Memo.t
-  val deps : Dep.Set.t -> expanded Memo.t
+  val alias : Alias.t -> Path.Set.t Memo.t
+  val deps : Dep.Set.t -> Path.Set.t Memo.t
 end = struct
-  let combine_both fa fb (a1, b1) (a2, b2) = fa a1 a2, fb b1 b2
-
   let alias =
     let memo =
       Memo.create
         "expand-alias"
         ~input:(module Alias)
         (fun alias ->
-           let* deps, anons =
+           let* deps =
              Load_rules.get_alias_definition alias
              >>= Memo.map_reduce
-                   ~empty:(Dep.Set.empty, Anon_rule.Set.empty)
-                   ~combine:(combine_both Dep.Set.union Anon_rule.Set.union)
+                   ~empty:Dep.Set.empty
+                   ~combine:Dep.Set.union
                    ~f:(fun (loc, definition) ->
                      Memo.push_stack_frame
                        (fun () ->
-                          match (definition : Rules.Dir_rules.Alias_spec.item) with
-                          | Deps x ->
-                            let+ (), deps = Action_builder.evaluate_and_collect_deps x in
-                            deps, Anon_rule.Set.empty
-                          | Action x ->
-                            Memo.return (Dep.Set.empty, Anon_rule.Set.singleton x))
+                          Action_builder.evaluate_and_collect_deps
+                            (Build_system.dep_on_alias_definition definition)
+                          >>| snd)
                        ~human_readable_description:(fun () -> Alias.describe alias ~loc))
            in
-           let+ expanded_deps, anons' = Expand.deps deps in
-           expanded_deps, Anon_rule.Set.union anons anons')
+           Expand.deps deps)
     in
     Memo.exec memo
   ;;
 
   let deps deps =
     Memo.map_reduce
       (Dep.Set.to_list deps)
-      ~empty:(Path.Set.empty, Anon_rule.Set.empty)
-      ~combine:(combine_both Path.Set.union Anon_rule.Set.union)
+      ~empty:Path.Set.empty
+      ~combine:Path.Set.union
       ~f:(fun (dep : Dep.t) ->
         match dep with
-        | File p -> Memo.return (Path.Set.singleton p, Anon_rule.Set.empty)
+        | File p -> Memo.return (Path.Set.singleton p)
         | File_selector g ->
           let+ filenames = Build_system.eval_pred g in
           (* Alas, we can't use filename sets here because we end up putting paths coming
            from different directories together. *)
-          Path.Set.of_list (Filename_set.to_list filenames), Anon_rule.Set.empty
+          Path.Set.of_list (Filename_set.to_list filenames)
         | Alias a -> Expand.alias a
-        | Env _ | Universe -> Memo.return (Path.Set.empty, Anon_rule.Set.empty))
+        | Env _ | Universe -> Memo.return Path.Set.empty)
   ;;
 end
 
@@ -78,71 +67,29 @@ let evaluate_rule =
       ~input:(module Non_evaluated_rule)
       (fun rule ->
          let* action, deps = Action_builder.evaluate_and_collect_deps rule.action in
-         let* expanded_deps, _ = Expand.deps deps in
+         let* expanded_deps = Expand.deps deps in
          Memo.return
            { Rule.id = rule.id
            ; deps
            ; expanded_deps
-           ; targets = Some rule.targets
+           ; targets = rule.targets
            ; action = action.action
-           ; aliases = None
-           ; loc = rule.loc
            })
   in
   Memo.exec memo
 ;;
 
-let evaluate_anonymous_action =
-  let memo =
-    Memo.create
-      "evaluate-anonymous-action"
-      ~input:(module Anon_rule)
-      (fun anon_action ->
-         let* action, deps =
-           Action_builder.evaluate_and_collect_deps anon_action.action
-         in
-         let* expanded_deps, _ = Expand.deps deps in
-         Memo.return
-           { Rule.id = anon_action.id
-           ; deps
-           ; expanded_deps
-           ; targets = None
-           ; action = action.action
-           ; aliases =
-               (match anon_action.aliases with
-                | [] -> None
-                | aliases -> Some aliases)
-           ; loc = anon_action.loc
-           })
-  in
-  Memo.exec memo
-;;
-
-let rules_of_dep_paths paths =
-  Path.Set.to_list paths
-  |> Memo.parallel_map ~f:(fun p ->
-    Load_rules.get_rule p
-    >>= function
-    | None -> Memo.return None
-    | Some rule -> evaluate_rule rule >>| Option.some)
-  >>| List.filter_opt
-;;
-
-let rules_of_anon_actions anons =
-  Anon_rule.Set.to_list anons |> Memo.parallel_map ~f:evaluate_anonymous_action
-;;
-
-let rules_of_deps deps =
-  let* dep_paths, anons = Expand.deps deps in
-  let+ dep_rules, anon_rules =
-    Memo.fork_and_join
-      (fun () -> rules_of_dep_paths dep_paths)
-      (fun () -> rules_of_anon_actions anons)
-  in
-  dep_rules @ anon_rules
-;;
-
 let eval ~recursive ~request =
+  let rules_of_deps deps =
+    Expand.deps deps
+    >>| Path.Set.to_list
+    >>= Memo.parallel_map ~f:(fun p ->
+      Load_rules.get_rule p
+      >>= function
+      | None -> Memo.return None
+      | Some rule -> evaluate_rule rule >>| Option.some)
+    >>| List.filter_opt
+  in
   let* (), deps = Action_builder.evaluate_and_collect_deps request in
   let* root_rules = rules_of_deps deps in
   Rule_top_closure.top_closure
@@ -154,18 +101,9 @@ let eval ~recursive ~request =
   | Error cycle ->
     User_error.raise
       [ Pp.text "Dependency cycle detected:"
-      ; Pp.chain cycle ~f:(fun { Rule.targets; loc; _ } ->
-          match targets with
-          | Some targets ->
-            Pp.verbatim
-              (Path.to_string_maybe_quoted (Path.build (Targets.Validated.head targets)))
-          | None ->
-            (* Anonymous actions have no targets; describe them by their location instead. *)
-            if Loc.is_none loc
-            then Pp.verbatim "<anonymous action>"
-            else (
-              let start = Loc.start loc in
-              Pp.verbatim
-                (sprintf "<anonymous action at %s:%d>" start.pos_fname start.pos_lnum)))
+      ; Pp.chain cycle ~f:(fun rule ->
+          Pp.verbatim
+            (Path.to_string_maybe_quoted
+               (Path.build (Targets.Validated.head rule.targets))))
       ]
 ;;

src/dune_engine/reflection.ml

@@ -8,10 +8,8 @@ module Rule : sig
     ; (* [expanded_deps] skips over non-file dependencies, such as: environment
          variables, universe, glob listings, sandbox requirements *)
       expanded_deps : Path.Set.t
-    ; targets : Targets.Validated.t option
+    ; targets : Targets.Validated.t
     ; action : Action.t
-    ; aliases : Alias_name.t list option
-    ; loc : Loc.t
     }
 end