What is a crate attribute and where do I add it?

by

A crate attribute is an attribute (#[...]) that applies to the enclosing context (#![...]). This attribute must be added to the top of your crate root, thus the context is the crate itself: 

#![attribute_name]
#![attribute_name(arg1, ...)]

If you are creating

  • a library — the crate root will be a file called lib.rs
  • an application — the crate root would be the primary .rs file you build. In many cases, this will be called main.rs
  • an integration test – the crate root is each file in tests/
  • an example – the crate root is each file in examples/

The Rust Programming Language and the Rust Reference talk a bit about attributes in general. The Unstable Book contains a list of feature flags and brief documentation on what they do.

There are many different crate attributes, but the feature crate attribute (#![feature(feature1, feature2)]) may only be used in a nightly version of the compiler. Unstable features are not allowed to be used in stable Rust versions.

More Related Contents:

  1. Package with both a library and a binary?
  2. Why are Rust executables so huge?
  3. How do I ‘pass down’ feature flags to subdependencies in Cargo?
  4. How do I use conditional compilation with `cfg` and Cargo?
  5. How do you enable a Rust “crate feature”?
  6. How can a Rust program access metadata from its Cargo package?
  7. How do I specify the linker path in Rust?
  8. Can Cargo download and build dependencies without also building the application?
  9. Is there a list of all cfg features?
  10. How to idiomatically alias a crate in Rust 2018?
  11. How to tell what “features” are available per crate?
  12. How can I build multiple binaries with Cargo?
  13. How to pass rustc flags to cargo?
  14. How do I pin indirect dependencies of a crate?
  15. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  16. Does println! borrow or own the variable?
  17. How do I pass disjoint slices from a vector to different threads?
  18. Why is it possible to implement Read on an immutable reference to File?
  19. Compare enums only by variant, not value
  20. How do you actually use dynamically sized types in Rust?
  21. How to operate on 2 mutable slices of a Rust array?
  22. Mutating one field while iterating over another immutable field
  23. How to match on data type in Rust?
  24. Why does Rust allow mutation through a reference field using an immutable binding?
  25. Multiple return types from a method
  26. Why does this mutable borrow live beyond its scope?
  27. Parameter type may not live long enough?
  28. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  29. Why is Rust’s assert_eq! implemented using a match?
  30. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?

Leave a Comment