7

I have a procedural macro that needs to store semi-persistent state. The state needs to survive compilation runs and should be cleaned up when cargo clean is run.

In the past, I used the ./target directory this purpose. However, this was a mistake because some of the files my procedural macro would generated could conflict with those generated by rustc and cargo. The location of the target directory can also be changed from the default.

Note that this question is not a duplicate of Is it possible to store state within Rust's procedural macros?. That question covers procedural macro state in general while this question is about determining a suitable location within a crate's file structure.

Tenders McChiken
  • 1,216
  • 13
  • 21
  • 1
    Note that the linked **answer** discusses using the filesystem for this state and lists a number of problems with it, such as it randomly and arbitrarily breaking. – Shepmaster May 20 '19 at 14:03
  • @Shepmaster Thank you for pointing that out (and fixing mistakes in my post). The answer does indeed discuss using the filesystem to store state, but not in a way that plays nice with a crate's file structure. My goal is to find a place within a crate's directory that can be automatically cleaned up by cargo. – Tenders McChiken May 20 '19 at 14:19
  • 1
    My point that is even if you find a place to store the data, the concept of storing intermediate state on the filesystem is fundamentally flawed. It doesn't matter *where* you store it if it's going to break when it's used. – Shepmaster May 20 '19 at 14:21
  • I'm not sure comments is the right place to have this discussion, but what makes you assume that it is intermediate state or that it would break if used? Could you please elaborate further? If it helps, the state I'm tracking lives across multiple compilations and isn't tied to compilation artifices but source code. – Tenders McChiken May 21 '19 at 03:27
  • 1
    FYI I actually built a whole crate around this concept -- https://crates.io/crates/macro_state :) – Sam Johnson Oct 13 '22 at 16:53

1 Answers1

3

It appears that the best place for storing temporary files that both (1) persist across compilation runs and (2) also get cleaned up by Cargo is to use OUT_DIR:

OUT_DIR — If the package has a build script, this is set to the folder where the build script should place its output. See below for more information. (Only set during compilation.)

This environment variable is only available to build scripts if I recall correctly, so you must use a build script to expose the path to the rest of crate. Do note that OUT_DIR is shared with any crate that uses your macros for a given compilation run, so you need to factor this in a way you use that directory to avoid conflicts.

This solution in steps:

  1. Re-export the OUT_DIR to the rest of the crate by adding the following line to the build script of your procedural macro crate:

     println!("cargo:rustc-env=PROC_ARTIFACT_DIR={}", 
          std::env::var("OUT_DIR").unwrap() )

  2. Use env!("PROC_ARTIFACT_DIR") in your procedural macros to get the path to the state directory.

This should only serve as a temporary workaround until Cargo supports temp directories (?) properly. Full credit for this method goes to @sven-marnach.

Tenders McChiken
  • 1,216
  • 13
  • 21