attribute-dsl 0.2.0

Shared parser helpers for Rust attribute DSLs built from paths and dot-call chains.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# Getting started

This path parses one path-rooted dot-call chain and inspects its root and calls.
A successful `cargo check` confirms the parser and `syn` types resolve in the
macro implementation crate.

## Prerequisites

- Rust 1.96 or newer.
- A derive-macro or attribute-macro implementation crate.
- A clear grammar for the attribute accepted by that macro.

## Add dependencies

Add `attribute-dsl` alongside the syntax dependencies used by the macro:

```toml
[dependencies]
attribute-dsl = "0.1"
quote = "1.0"
syn = { features = [ "full" ], version = "2.0" }
```

## Parse a chain

`AttributeChain` implements `syn::parse::Parse`, so it works with attribute
argument parsing and `syn::parse_str`:

```rust,ignore
use attribute_dsl::AttributeChain;

let chain: AttributeChain =
    syn::parse_str("RootType::<_>.first(1).second::<String>(\"value\")")?;

assert_eq!(
    chain
        .root_path()
        .segments
        .last()
        .expect("a parsed path has a segment")
        .ident,
    "RootType"
);
assert_eq!(chain.calls().len(), 2);

# Ok::<(), syn::Error>(())
```

In a proc macro, use `attr.parse_args::<AttributeChain>()?` to retain the
attribute's source spans in diagnostics.

## Verify the integration

Run `cargo check` in the macro workspace. A successful check confirms that the
crate versions resolve and the selected parser API is available.

If parsing fails, return the `syn::Error` from the macro expansion path or
combine it with other spanned diagnostics. Do not replace it with a string-only
error, because callers need the source span to locate invalid syntax.