Modified the named target

Signed-off-by: Anthony Onah <[email protected]>

Author: create2000

src/dune_lang/action.ml

@@ -2,6 +2,7 @@ open Stdune
 open Dune_sexp
 open Dune_util.Action
 open Pform.Macro
+open Pform
 
 module Named_targets = struct
   type t = (string * String_with_vars.t) list
@@ -25,7 +26,7 @@ module Pform = struct
       | C_flags
       | Cxx_flags
       | Cpp_flags
-      | Target of string  (* New variant for named targets *)
+      | Target of string (* New variant for named targets *)
       | Ocaml
       | Ocamlc
       | Ocamlopt
@@ -62,8 +63,8 @@ module Pform = struct
 
     let compare = compare
   end
-  type t =
-    | Var of Var.t
+
+  type t = Var of Var.t
 end
 
 module Diff = struct
@@ -162,7 +163,7 @@ module Env_update = struct
 
   type 'a t =
     { op : Op.t
-    ; var : Env.Var.t
+    ; var : Var.t
     ; value : 'a
     }
 
@@ -174,28 +175,36 @@ module Env_update = struct
         { op = other_op; var = other_var; value = other_value }
     =
     Op.equal op other_op
-    && Ordering.is_eq (Env.Var.compare var other_var)
+    && Var.compare var other_var = Ordering.Eq
     && value_equal value other_value
   ;;
 
   let to_dyn value_to_dyn { op; var; value } =
-    Dyn.record
-      [ "op", Op.to_dyn op; "var", Env.Var.to_dyn var; "value", value_to_dyn value ]
+    Dyn.record [ "op", Op.to_dyn op; "var", Var.to_dyn var; "value", value_to_dyn value ]
   ;;
 
   let decode =
     let open Decoder in
     let env_update_op = enum Op.all in
     let+ op, var, value = triple env_update_op string String_with_vars.decode in
-    { op; var; value }
+    { op; var = Var.User_var var; value }
   ;;
 
   let encode { op; var; value } =
-    let op =
+    let op_str =
       List.find_map Op.all ~f:(fun (k, v) -> if Poly.equal v op then Some k else None)
       |> Option.value_exn
     in
-    List [ atom op; atom var; String_with_vars.encode value ]
+    let var_str =
+      match var with
+      | Var.User_var s -> s
+      | Var.Target -> "target"
+      | _ ->
+        (* Handle other cases or raise an error *)
+        Code_error.raise "Action.encode: unsupported variable" []
+    in
+    Dune_sexp.List
+      [ Dune_sexp.atom op_str; Dune_sexp.atom var_str; String_with_vars.encode value ]
   ;;
 end
 
@@ -232,63 +241,73 @@ type t =
   | When of Slang.blang * t
   | Format_dune_file of String_with_vars.t * String_with_vars.t
 
-type expansion_context = {
-  dir : Path.t;
-  (* ... other fields ... *)
-  named_targets : Named_targets.t;
-}
+type expansion_context =
+  { dir : Path.t
+  ; named_targets : (string * String_with_vars.t) list
+  ; named_deps : (string * Dep_conf.t) list
+  }
+
 let is_dev_null t = String_with_vars.is_pform t (Var Dev_null)
 
 let translate_to_ignore fn output action =
   if is_dev_null fn
   then Ignore (output, action)
   else Redirect_out (output, fn, Normal, action)
 ;;
-let expand_target_var ~loc ~named_targets name =
-  match List.assoc_opt name named_targets with
-  | Some target -> 
-    (match String_with_vars.text_only target with
-     | Some text -> text
-     | None ->
-       User_error.raise ~loc [
-         Pp.textf "Named target '%s' contains variables and cannot be expanded here" name
-       ])
-  | None ->
-    User_error.raise ~loc [
-      Pp.textf "Undefined named target: %s" name;
-      Pp.text "Available named targets:";
-      Pp.enumerate named_targets ~f:(fun (name, _) -> Pp.text name)
-    ]
-  ;;
+
 let expand_str ~context sw =
   let module S = String_with_vars in
-
   match S.text_only sw with
   | Some s -> s
   | None ->
     let expand_var = function
-      | Pform.Var var ->
-        if String.equal (Pform.Var.to_string var) "target" then
-          (match context.named_targets with
-          | (name, target) :: _ -> S.to_string target
-          | [] -> "%{target}")
-        else
-          S.to_string (S.make_var (S.loc sw) (Pform.Var var))
+      | Pform.Var (Var.User_var name) ->
+        (* Fixed pattern *)
+        (match List.assoc_opt name context.named_targets with
+         | Some target -> S.to_string target
+         | None ->
+           (match List.assoc_opt name context.named_deps with
+            | Some dep -> Dep_conf.to_string dep
+            | None ->
+              User_error.raise
+                ~loc:(S.loc sw)
+                [ Pp.textf "Undefined variable %%{%s}" name
+                ; Pp.text "Available variables:"
+                ; Pp.enumerate
+                    (List.map
+                       (context.named_targets @ context.named_deps)
+                       ~f:(fun (n, _) -> n))
+                ]))
+      | Pform.Var Var.Target ->
+        (* Correct pattern *)
+        (match List.assoc_opt "target" context.named_targets with
+         | Some target -> S.to_string target
+         | None ->
+           User_error.raise ~loc:(S.loc sw) [ Pp.text "Undefined target %{target}" ])
+      | Pform.Var other_var ->
+        (* Handle other built-in variables *)
+        S.to_string (S.make_var (S.loc sw) (Pform.Var other_var))
+      | Pform.Macro macro ->
+        (* Handle macros *)
+        S.to_string (S.make_var (S.loc sw) (Pform.Macro macro))
     in
     S.expand sw ~f:expand_var
-    ;;  
+;;
 
 let create_action targets action =
-  let named_targets = 
+  let named_targets =
     List.filter_map targets ~f:(fun (target, _, name) ->
-      Option.map name ~f:(fun n -> (n, target)))
+      Option.map name ~f:(fun n -> n, target))
   in
-  { action with 
-    expansion_context = { 
-      dir = Path.root;
-      named_targets 
-    } 
+  { action with
+    expansion_context =
+      { dir = Path.root
+      ; named_targets
+      ; named_deps = [] (* Will be populated from rule.deps later *)
+      }
   }
+;;
+
 let two_or_more decode =
   let open Decoder in
   let+ n1 = decode
@@ -360,15 +379,17 @@ let decode_with_accepted_exit_codes =
 
 let decode_rule =
   let open Decoder in
-  let* targets = 
-    repeat (
-      let* target = String_with_vars.decode in
-      let* name = optional string in
-      return (target, (), name)
-    )
-  in
-  let* action = decode_dune_file in
-  return (create_action targets action)
+  let+ targets =
+    repeat
+      (let* target = String_with_vars.decode in
+       let* name = optional string in
+       return (target, (), name))
+  and+ deps = field "deps" (Bindings.decode Dep_conf.decode) ~default:Bindings.empty
+  and+ action = decode_dune_file in
+  let rule = create_action targets action in
+  { rule with
+    expansion_context = { rule.expansion_context with named_deps = Bindings.to_list deps }
+  }
 ;;
 
 let sw = String_with_vars.decode

src/dune_lang/bindings.ml

@@ -90,3 +90,27 @@ let to_pform_map t =
        | Unnamed _ -> None
        | Named (name, l) -> Some (Pform.Var (User_var name), l)))
 ;;
+
+let is_empty b = b = []
+
+let get_target_by_name name bindings =
+  let rec find_target = function
+    | [] -> None
+    | Unnamed target :: rest ->
+      (match String_with_vars.text_only target with
+       | Some s when s = name -> Some target
+       | _ -> find_target rest)
+    | Named (_, targets) :: rest ->
+      (match
+         List.find
+           ~f:(fun t ->
+             match String_with_vars.text_only t with
+             | Some s -> s = name
+             | None -> false)
+           targets
+       with
+       | Some target -> Some target
+       | None -> find_target rest)
+  in
+  find_target bindings
+;;

src/dune_lang/bindings.mli

@@ -18,3 +18,5 @@ val decode : 'a Dune_sexp.Decoder.t -> 'a t Dune_sexp.Decoder.t
 val encode : 'a Dune_sexp.Encoder.t -> 'a t -> Dune_sexp.t
 val var_names : _ t -> string list
 val to_pform_map : 'a t -> 'a list Pform.Map.t
+val is_empty : 'a t -> bool
+val get_target_by_name : string -> String_with_vars.t t -> String_with_vars.t option