1. Symptoms
When the Rust compiler encounters a malformed attribute, it halts compilation and emits error E0367. This error manifests with several observable indicators that help developers identify the problematic code location.
The compiler output typically includes the error code, a descriptive message, and a span pointing to the offending attribute. The error message generally reads “malformed attribute attribute, expected (” or a similar variant indicating the expected syntax structure.
error[E0367]: malformed `attribute` attribute, expected `(`
--> src/main.rs:5:8
|
5 | #[derive(Debug]
| ^^^^^^^^ expected `(`
In more complex scenarios, the error may involve nested attributes or attributes applied to non-item contexts:
error[E0367]: malformed `cfg` attribute, expected a condition
--> src/lib.rs:12:1
|
12 | #[cfg(feature = ]
| ^^^^^^^^^^^^^^^^^ expected a condition
Additional symptoms include complete compilation failure, with no binary or library artifacts generated, and the compiler stopping at the first encountered attribute syntax error rather than continuing to report subsequent issues in the file.
2. Root Cause
The root cause of error E0367 lies in violations of Rust’s attribute syntax rules. Attributes in Rust follow a precise grammar that the compiler strictly enforces during parsing, before any semantic analysis occurs.
Attributes begin with a hash symbol (#) followed by an optional outer attribute delimiter (! for non-derive attributes) and then a square bracket pair ([...]) containing the attribute name and optional arguments. The arguments themselves must conform to specific patterns depending on the attribute type. For example, the #[derive(...)] attribute requires a comma-separated list of valid trait names within its parentheses, while #[cfg(...)] requires a valid conditional expression.
Common violations that trigger E0367 include mismatched delimiters such as using a brace { or curly bracket where a parenthesis ( is expected. Another frequent cause is malformed expressions within attribute arguments, such as incomplete string literals, unclosed brackets, or invalid token sequences that cannot be parsed as valid attribute content.
The error also occurs when attributes are applied to contexts where they are not permitted. Certain attributes have specific placement requirementsβthey may only be valid on functions, structs, enums, impl blocks, or other specific syntactic constructs. Attempting to apply an attribute to an incompatible item results in this syntax error.
3. Step-by-Step Fix
Resolving E0367 requires identifying the specific syntax violation and correcting the attribute structure to match Rust’s grammar requirements. The following steps guide you through systematic diagnosis and resolution.
Step 1: Locate the exact problematic attribute
The compiler output includes a file path and line number indicating the attribute causing the error. Examine that specific line and verify the attribute syntax matches the expected pattern for its type.
Step 2: Verify matching delimiters
Ensure all opening delimiters have corresponding closing delimiters of the same type:
Before:
#[derive(Debug]
struct User {
name: String,
}
After:
#[derive(Debug)]
struct User {
name: String,
}
Step 3: Check attribute argument syntax
For attributes requiring arguments, verify the expression inside the delimiters is syntactically complete and valid:
Before:
#[cfg(feature = "serde")]
After:
#[cfg(feature = "serde")]
Step 4: Validate attribute placement
Confirm the attribute is applicable to the item it decorates:
Before:
struct Config {
#[allow(dead_code)]
timeout: u64,
}
After:
struct Config {
#[allow(dead_code)]
timeout: u64,
}
Step 5: Use raw string literals for complex content
When attribute arguments contain special characters, raw strings may be necessary:
Before:
#[doc = "Documentation with \"quotes\" inside"]
After:
#[doc = r#"Documentation with "quotes" inside"#]
4. Verification
After applying the fix, verify the resolution by recompiling the affected crate. A successful fix results in the complete absence of error E0367 from the compiler output.
Run the following command to verify:
cargo build
If the fix is successful, the build completes without E0367:
Compiling myproject v0.1.0 (file:///path/to/project)
Finished dev [unoptimized + debuginfo] target(s) in 2.34s
For more thorough verification, especially in complex projects with multiple crates, run the full test suite:
cargo test
This ensures that attribute-related fixes do not introduce regressions in dependent code. If the project uses clippy for additional linting, run it to catch any subtle attribute misuse:
cargo clippy
Additionally, verify that the attribute’s semantic behavior remains correct. For instance, after fixing a #[cfg(...)] attribute, confirm that conditional compilation operates as intended by testing with different feature flags.
5. Common Pitfalls
Several recurring mistakes lead developers to encounter E0367 repeatedly. Avoiding these pitfalls significantly reduces frustration and development time.
The most frequent pitfall involves forgetting to close parentheses or brackets in attribute arguments. This simple typo commonly occurs when adding multiple attributes to a single item or when modifying existing attributes. Always visually scan attribute delimiters as a pair, checking that each opening delimiter has a corresponding closing delimiter on the same line or appropriately nested.
Another common mistake is copying attribute syntax from external sources without adjusting for Rust’s syntax requirements. Documentation, blog posts, and code examples sometimes contain typographical errors or use different syntax conventions that do not compile. Always verify attribute syntax against the official Rust documentation or the standard library source code.
Developers frequently misuse raw strings within attributes. When path strings contain backslashes (especially on Windows), the escaped backslash sequence can break attribute parsing. Using raw string literals (r"...") or forward slashes in paths mitigates this issue.
Forgetting the ! when applying non-derive attributes to macro definitions leads to E0367. Inner attributes and outer attributes have distinct syntax requirements, and mixing them incorrectly causes parsing failures.
Finally, attempting to apply multiple attributes with mismatched grouping confuses the compiler. Each attribute must be self-contained within its own #[...] delimiters; attributes cannot span multiple bracket pairs or share delimiters.
6. Related Errors
Error E0367 frequently appears alongside several related compiler errors that stem from similar attribute syntax violations.
**E0517 - “invalid noise”} This error occurs when an attribute contains unexpected or invalid tokens. While E0367 focuses on structural malformedness, E0517 targets specific invalid characters or sequences within otherwise correctly structured attributes.
**E0603 - “invalid module attribute”} This error applies when attributes are applied incorrectly to modules. It often accompanies E0367 when developers attempt to use module-level attributes with incorrect syntax or in improper positions within the source file.
**E0698 - “attribute supports no expression”} This error emerges when an attribute that does not accept arguments is given arguments, or when the argument syntax is incompatible with the attribute’s expected format. It represents a semantic mismatch within an attribute that passes basic syntax checks.
Understanding the relationship between these errors helps developers distinguish between purely syntactic violations (E0367) and semantically invalid attribute usage patterns. When encountering attribute errors, systematically work from syntax correctness (E0367) to semantic validity (E0517, E0603, E0698) for efficient debugging.