~dependencies ~features ~opt_level ~is_top_level =

  ~dependencies ~features ~opt_level ~is_top_level ~extra_crate_dependencies =

    method description =
      try package |> member "description" |> to_string with _ -> ""

    method lib_name =
      try
        Some
          (List.find
             (fun x ->
               let kind = x |> member "kind" |> to_list |> filter_string in
               kind = [ "lib" ] || kind = [ "proc-macro" ])
             self#targets
          |> member "name" |> to_string)
      with Not_found -> None

           export CC_ENABLE_DEBUG_OUTPUT=1
           export CC=$(command -v clang)

           echo "sourcing env"

      let dependencies_str =

      (* rustc wants a single (or few) `-L dependency=` flag, else it
         seems to ignore some of them. That's why we copy deps and
         transitive deps to target/deps. *)
      let dependencies_str, target_deps =

          (fun acc (rename, name, h, is_proc_macro, b) ->
            acc ^ " --extern " ^ underscorize rename ^ "=" ^ List.hd b.destdir
            ^ "/lib/lib" ^ underscorize name ^ "-" ^ h
            ^
            if is_proc_macro then ".so"
            else if kind = "lib" then ".rmeta"
            else ".rlib")
          "" dependencies

          (fun (acc_extern, acc_ln) (rename, lib_name, h, is_proc_macro, b) ->
            let acc_extern =
              acc_extern ^ " --extern " ^ underscorize rename
              ^ "=target/deps/lib" ^ underscorize lib_name ^ "-" ^ h
              ^ if is_proc_macro then ".so" else ".rlib"
            in
            let acc_ln =
              acc_ln ^ "ln -sf " ^ List.hd b.destdir ^ "/lib/* target/deps\n"
            in
            (acc_extern, acc_ln))
          ("", "mkdir -p target/deps\n")
          dependencies

      let dependencies_str =

      let target_deps =

          (fun _ v acc -> acc ^ " -L dependency=" ^ List.hd v.destdir ^ "/lib")
          transitive_dependencies dependencies_str

          (fun _ v acc ->
            acc ^ "ln -sf " ^ List.hd v.destdir ^ "/lib/* target/deps\n")
          transitive_dependencies target_deps

        let local =
          match self#lib_name with
          | Some l ->
              "--extern " ^ underscorize l ^ "=$DESTDIR/lib/lib"
              ^ underscorize l ^ "-" ^ self#hash ^ ".rlib"
          | None -> ""
        in

             set -xe

             set -x
             rustc --crate-name %{under} %{edition} %{src_path} %{target} --crate-type bin -C linker=gcc $RUSTC_FLAGS %{features_args} -C metadata=%{hash} --out-dir %{out} %{dependencies_str} -L dependency=../lib --cap-lints allow
             { set +x; } 2>/dev/null

             mkdir -p target %{out} $DESTDIR
             touch target/rustc.opt
             RUSTC_FLAGS=$(cat target/rustc.opt)
             find $DESTDIR
             %{target_deps}
             rustc --crate-name %{under} %{edition} %{src_path} %{target} --crate-type bin --emit=link -C linker=gcc $RUSTC_FLAGS %{features_args} -C metadata=%{hash}-bin --out-dir %{out} %{dependencies_str} %{local} -L dependency=target/deps --cap-lints allow

             set -xe

             set -x
             rustc --crate-name %{under} %{edition} %{src_path} --crate-type %{kind} %{target} --emit=dep-info,metadata,link -C linker=gcc -C embed-bitcode=no -C debuginfo=2 $RUSTC_FLAGS %{if kind = "proc-macro" then " -C prefer-dynamic" else ""} %{features_args} -C metadata=%{hash} --out-dir %{out} -C extra-filename=-%{hash} %{dependencies_str} %{if kind = "proc-macro" then " --extern proc_macro" else ""} --cap-lints allow
             { set +x; } 2>/dev/null

             mkdir -p target %{out}
             touch target/rustc.opt
             RUSTC_FLAGS=$(cat target/rustc.opt)
             %{target_deps}
             rustc --crate-name %{under} %{edition} %{src_path} --crate-type %{kind} %{target} --emit=link -C linker=gcc -C embed-bitcode=no -C debuginfo=2 $RUSTC_FLAGS %{if kind = "proc-macro" then " -C prefer-dynamic" else ""} %{features_args} -C metadata=%{hash} --out-dir %{out} -C extra-filename=-%{hash} %{dependencies_str} %{if kind = "proc-macro" then " --extern proc_macro" else ""} -L dependency=target/deps --cap-lints allow

                Hashtbl.add h d#name d;

                Hashtbl.add h d#hash d;

                let x_lib_name = Option.get x#lib_name in

                r := (name, x_name, x_hash, is_proc_macro, b) :: !r;

                r := (name, x_lib_name, x_hash, is_proc_macro, b) :: !r;

    method extra_deps =
      List.fold_left
        (fun acc dep ->
          let* acc = acc in
          let* extra = dep#extra_deps in
          Lwt.return (extra @ acc))
        (Lwt.return (extra_crate_dependencies self#name self#version))
        dependencies

      let* extra = self#extra_deps in

           ubuntu "clang";
           ubuntu "libc6-dev";

           ubuntu "findutils";

        @ extra_crate_dependencies self#name self#version)

        @ extra)

        ref ("mkdir -p target/build-" ^ hash ^ "\nexport RUSTC=rustc\n")

        ref
          ("mkdir -p target/build-" ^ hash
         ^ "\nexport RUSTC=rustc\ntouch target/rustc.opt\n")

      let links =
        try Some (package |> member "links" |> to_string)
        with Not_found | Yojson.Basic.Util.Type_error _ -> None
      in

      let description =
        Str.global_replace
          (Str.regexp "\"\\|`\\|\\$\\|\\")
          "\\\\\\0" self#description
      in

            {|export OUT_DIR=$DESTDIR/lib

            {|
             export OUT_DIR=$DESTDIR/lib
             export CC_ENABLE_DEBUG_OUTPUT=1

             export CARGO_PKG_DESCRIPTION="%{description}"

             export CARGO_PKG_VERSION_PATCH=%{Option.value v4 ~default:""}

             export CARGO_PKG_VERSION_PRE=%{Option.value v4 ~default:""}
             export CARGO_MANIFEST_DIR=$(pwd)/%{name}-%{version}
             export CARGO_MANIFEST_LINKS=%{Option.value links ~default: ""}

                   echo Running build script for %{name}-%{version}

                      d.transitive_dependencies d.dependencies "$OUT_DIR"

                      d.transitive_dependencies d.dependencies "$DESTDIR/lib"

                        d.transitive_dependencies d.dependencies
                        "$OUT_DIR/../bin"

                        d.transitive_dependencies d.dependencies "$DESTDIR/bin"

    ?(host = !Platform.host) src =

    ?(host = !Platform.host)
    ?(extra_crate_dependencies = extra_crate_dependencies) src =

      let is_top_level = List.exists (fun w -> w = name) workspace_members in
      let cc = (cc :> derivation) in

      let is_top_level = List.exists (fun w -> w = id) workspace_members in
      let cc = (cc Clang :> derivation) in

          ~dependencies ~features ~opt_level:"3" ~is_top_level

          ~extra_crate_dependencies ~dependencies ~features ~opt_level:"3"
          ~is_top_level

    eval $(echo $cargo | sed -ne 's/cargo:rustc-link-arg=\(.*\)/RUSTC_FLAGS="-C link_arg=\1 $RUSTC_FLAGS"/p')

    echo $cargo # | grep -v "^\(#\|cargo:\)"
    echo $cargo | sed -ne 's/cargo:rustc-link-arg=\(.*\)/-C link_arg=\1/p' >> target/rustc.opt

    eval $(echo $cargo | sed -ne 's/cargo:rustc-link-lib=\(.*\)/RUSTC_FLAGS="-l\1 $RUSTC_FLAGS"/p')

    echo $cargo | sed -ne 's/cargo:rustc-link-lib=\(.*\)/-l \1/p' >> target/rustc.opt

    eval $(echo $cargo | sed -ne 's/cargo:rustc-link-search=\(.*\)/RUSTC_FLAGS="-L\1 $RUSTC_FLAGS"/p')

    echo $cargo | sed -ne 's/cargo:rustc-link-search=\(.*\)/-L \1/p' >> target/rustc.opt

    eval $(echo $cargo | sed -ne "s/cargo:rustc-cfg=\(.*\)/RUSTC_FLAGS='--cfg \1 $RUSTC_FLAGS'/p")

    echo $cargo | sed -ne 's/cargo:rustc-cfg=\(.*\)/--cfg \1/p' >> target/rustc.opt

    eval $(echo $cargo | sed -ne 's/cargo:rustc-flags=\(.*\)/RUSTC_FLAGS="\1 $RUSTC_FLAGS"/p')

    echo $cargo | sed -ne 's/cargo:rustc-flags=\(.*\)/\1/p' >> target/rustc.opt

(preprocessor_deps (file run_build_script.sh))

(preprocessor_deps (file rust/run_build_script.sh))

let link_extra = [ ("libstd-rust-.*-dev", "libstd-rust.*") ]

let link_extra =
  [ ("libstd-rust-.*-dev", "libstd-rust.*"); ("clang", "clang-.*") ]

              let c =
                match !backend_conn with
                | None -> failwith "no conn"
                | Some c -> c
              in
              let* index =
                Lwt_list.map_p
                  (fun repository ->
                    let arch =
                      match platform.arch with
                      | Amd64 -> Elpegrpc.Elpe.Arch.Amd64
                      | Aarch64 -> Elpegrpc.Elpe.Arch.Aarch64
                    in
                    let* res = ubuntu_release c ~release ~arch ~repository in
                    let res, _ = Result.get_ok res in
                    match res with
                    | `Ok r -> Lwt.return r.destdir
                    | `Error e -> raise (DerivationError e)
                    | _ -> assert false)
                  [ "main"; "universe" ]
              in
              let index = List.concat index in
              let* res = ubuntu_package c ~index ~name in
              let r = Result.get_ok res in
              let x = { destdir = r.destdir; paths = r.paths } in
              cached_build := Some x;
              Lwt.return x)

              match !cached_build with
              | Some x -> Lwt.return x
              | None ->
                  let c =
                    match !backend_conn with
                    | None -> failwith "no conn"
                    | Some c -> c
                  in
                  let* index =
                    Lwt_list.map_p
                      (fun repository ->
                        let arch =
                          match platform.arch with
                          | Amd64 -> Elpegrpc.Elpe.Arch.Amd64
                          | Aarch64 -> Elpegrpc.Elpe.Arch.Aarch64
                        in
                        let* res =
                          ubuntu_release c ~release ~arch ~repository
                        in
                        let res, _ = Result.get_ok res in
                        match res with
                        | `Ok r -> Lwt.return r.destdir
                        | `Error e -> raise (DerivationError e)
                        | _ -> assert false)
                      [ "main"; "universe" ]
                  in
                  let index = List.concat index in
                  let* res = ubuntu_package c ~index ~name in
                  let r = Result.get_ok res in
                  let x = { destdir = r.destdir; paths = r.paths } in
                  cached_build := Some x;
                  Lwt.return x)

let cc =

type cc = Gcc | Clang
let cc x =
  let x = match x with Gcc -> "gcc" | Clang -> "clang" in

    method! build_inputs = Lwt.return [ ubuntu "coreutils"; ubuntu "gcc" ]

    method! build_inputs = Lwt.return [ ubuntu "coreutils"; ubuntu x ]

      let* gcc = (ubuntu "gcc")#build in
      List.iter self#add_path gcc.destdir;

      let* cc = (ubuntu x)#build in
      List.iter self#add_path cc.destdir;

        ("mkdir -p $DESTDIR/usr/bin; ln -s " ^ List.hd gcc.destdir
       ^ "/usr/bin/gcc $DESTDIR/usr/bin/cc")

        ("mkdir -p $DESTDIR/usr/bin; ln -s " ^ List.hd cc.destdir ^ "/usr/bin/"
       ^ x ^ " $DESTDIR/usr/bin/cc")