David Tolnay | 5553501 | 2018-01-05 16:39:23 -0800 | [diff] [blame] | 1 | // Copyright 2018 Syn Developers |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| 4 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| 5 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| 6 | // option. This file may not be copied, modified, or distributed |
| 7 | // except according to those terms. |
| 8 | |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 9 | use super::*; |
David Tolnay | f2cfd72 | 2017-12-31 18:02:51 -0500 | [diff] [blame] | 10 | use punctuated::Punctuated; |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 11 | |
David Tolnay | 4a51dc7 | 2016-10-01 00:40:31 -0700 | [diff] [blame] | 12 | use std::iter; |
| 13 | |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 14 | use proc_macro2::{Delimiter, Spacing, TokenNode, TokenStream, TokenTree}; |
David Tolnay | 9c76bcb | 2017-12-26 23:14:59 -0500 | [diff] [blame] | 15 | |
| 16 | #[cfg(feature = "extra-traits")] |
| 17 | use std::hash::{Hash, Hasher}; |
| 18 | #[cfg(feature = "extra-traits")] |
David Tolnay | c43b44e | 2017-12-30 23:55:54 -0500 | [diff] [blame] | 19 | use tt::TokenStreamHelper; |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 20 | |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 21 | ast_struct! { |
David Tolnay | 2355714 | 2018-01-06 22:45:40 -0800 | [diff] [blame] | 22 | /// An attribute like `#[repr(transparent)]`. |
| 23 | /// |
David Tolnay | 461d98e | 2018-01-07 11:07:19 -0800 | [diff] [blame] | 24 | /// *This type is available if Syn is built with the `"derive"` or `"full"` |
| 25 | /// feature.* |
| 26 | /// |
David Tolnay | 2355714 | 2018-01-06 22:45:40 -0800 | [diff] [blame] | 27 | /// # Syntax |
| 28 | /// |
| 29 | /// Rust has six types of attributes. |
| 30 | /// |
| 31 | /// - Outer attributes like `#[repr(transparent)]`. These appear outside or |
| 32 | /// in front of the item they describe. |
| 33 | /// - Inner attributes like `#![feature(proc_macro)]`. These appear inside |
| 34 | /// of the item they describe, usually a module. |
| 35 | /// - Outer doc comments like `/// # Example`. |
| 36 | /// - Inner doc comments like `//! Please file an issue`. |
| 37 | /// - Outer block comments `/** # Example */`. |
| 38 | /// - Inner block comments `/*! Please file an issue */`. |
| 39 | /// |
| 40 | /// The `style` field of type `AttrStyle` distinguishes whether an attribute |
| 41 | /// is outer or inner. Doc comments and block comments are promoted to |
| 42 | /// attributes that have `is_sugared_doc` set to true, as this is how they |
| 43 | /// are processed by the compiler and by `macro_rules!` macros. |
| 44 | /// |
| 45 | /// The `path` field gives the possibly colon-delimited path against which |
| 46 | /// the attribute is resolved. It is equal to `"doc"` for desugared doc |
| 47 | /// comments. The `tts` field contains the rest of the attribute body as |
| 48 | /// tokens. |
| 49 | /// |
| 50 | /// ```text |
| 51 | /// #[derive(Copy)] #[crate::precondition x < 5] |
| 52 | /// ^^^^^^~~~~~~ ^^^^^^^^^^^^^^^^^^^ ~~~~~ |
| 53 | /// path tts path tts |
| 54 | /// ``` |
| 55 | /// |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 56 | /// Use the [`interpret_meta`] method to try parsing the tokens of an |
| 57 | /// attribute into the structured representation that is used by convention |
| 58 | /// across most Rust libraries. |
David Tolnay | 2355714 | 2018-01-06 22:45:40 -0800 | [diff] [blame] | 59 | /// |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 60 | /// [`interpret_meta`]: #method.interpret_meta |
David Tolnay | 9c76bcb | 2017-12-26 23:14:59 -0500 | [diff] [blame] | 61 | pub struct Attribute #manual_extra_traits { |
David Tolnay | f8db7ba | 2017-11-11 22:52:16 -0800 | [diff] [blame] | 62 | pub pound_token: Token![#], |
David Tolnay | 4a3f59a | 2017-12-28 21:21:12 -0500 | [diff] [blame] | 63 | pub style: AttrStyle, |
David Tolnay | 32954ef | 2017-12-26 22:43:16 -0500 | [diff] [blame] | 64 | pub bracket_token: token::Bracket, |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 65 | pub path: Path, |
David Tolnay | 369f0c5 | 2017-12-27 01:50:45 -0500 | [diff] [blame] | 66 | pub tts: TokenStream, |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 67 | pub is_sugared_doc: bool, |
| 68 | } |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 69 | } |
| 70 | |
David Tolnay | 9c76bcb | 2017-12-26 23:14:59 -0500 | [diff] [blame] | 71 | #[cfg(feature = "extra-traits")] |
| 72 | impl Eq for Attribute {} |
| 73 | |
| 74 | #[cfg(feature = "extra-traits")] |
| 75 | impl PartialEq for Attribute { |
| 76 | fn eq(&self, other: &Self) -> bool { |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 77 | self.style == other.style && self.pound_token == other.pound_token |
| 78 | && self.bracket_token == other.bracket_token && self.path == other.path |
David Tolnay | 369f0c5 | 2017-12-27 01:50:45 -0500 | [diff] [blame] | 79 | && TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) |
David Tolnay | 9c76bcb | 2017-12-26 23:14:59 -0500 | [diff] [blame] | 80 | && self.is_sugared_doc == other.is_sugared_doc |
| 81 | } |
| 82 | } |
| 83 | |
| 84 | #[cfg(feature = "extra-traits")] |
| 85 | impl Hash for Attribute { |
| 86 | fn hash<H>(&self, state: &mut H) |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 87 | where |
| 88 | H: Hasher, |
David Tolnay | 9c76bcb | 2017-12-26 23:14:59 -0500 | [diff] [blame] | 89 | { |
| 90 | self.style.hash(state); |
| 91 | self.pound_token.hash(state); |
| 92 | self.bracket_token.hash(state); |
| 93 | self.path.hash(state); |
David Tolnay | 369f0c5 | 2017-12-27 01:50:45 -0500 | [diff] [blame] | 94 | TokenStreamHelper(&self.tts).hash(state); |
David Tolnay | 9c76bcb | 2017-12-26 23:14:59 -0500 | [diff] [blame] | 95 | self.is_sugared_doc.hash(state); |
| 96 | } |
| 97 | } |
| 98 | |
David Tolnay | 02d77cc | 2016-10-02 09:52:08 -0700 | [diff] [blame] | 99 | impl Attribute { |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 100 | /// Parses the tokens after the path as a [`Meta`](enum.Meta.html) if |
| 101 | /// possible. |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 102 | pub fn interpret_meta(&self) -> Option<Meta> { |
Arnavion | 95f8a7a | 2017-04-19 03:29:56 -0700 | [diff] [blame] | 103 | let name = if self.path.segments.len() == 1 { |
David Tolnay | 5608068 | 2018-01-06 14:01:52 -0800 | [diff] [blame] | 104 | &self.path.segments.first().unwrap().value().ident |
Arnavion | 95f8a7a | 2017-04-19 03:29:56 -0700 | [diff] [blame] | 105 | } else { |
| 106 | return None; |
| 107 | }; |
| 108 | |
Arnavion | bf395bf | 2017-04-15 15:35:22 -0700 | [diff] [blame] | 109 | if self.tts.is_empty() { |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 110 | return Some(Meta::Word(*name)); |
Arnavion | bf395bf | 2017-04-15 15:35:22 -0700 | [diff] [blame] | 111 | } |
| 112 | |
David Tolnay | 369f0c5 | 2017-12-27 01:50:45 -0500 | [diff] [blame] | 113 | let tts = self.tts.clone().into_iter().collect::<Vec<_>>(); |
| 114 | |
| 115 | if tts.len() == 1 { |
| 116 | if let TokenNode::Group(Delimiter::Parenthesis, ref ts) = tts[0].kind { |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 117 | let tokens = ts.clone().into_iter().collect::<Vec<_>>(); |
| 118 | if let Some(nested_meta_items) = list_of_nested_meta_items_from_tokens(&tokens) { |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 119 | return Some(Meta::List(MetaList { |
David Tolnay | 369f0c5 | 2017-12-27 01:50:45 -0500 | [diff] [blame] | 120 | paren_token: token::Paren(tts[0].span), |
David Tolnay | bb4ca9f | 2017-12-26 12:28:58 -0500 | [diff] [blame] | 121 | ident: *name, |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 122 | nested: nested_meta_items, |
| 123 | })); |
Arnavion | bf395bf | 2017-04-15 15:35:22 -0700 | [diff] [blame] | 124 | } |
| 125 | } |
| 126 | } |
| 127 | |
David Tolnay | 369f0c5 | 2017-12-27 01:50:45 -0500 | [diff] [blame] | 128 | if tts.len() == 2 { |
| 129 | if let TokenNode::Op('=', Spacing::Alone) = tts[0].kind { |
| 130 | if let TokenNode::Literal(ref lit) = tts[1].kind { |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 131 | return Some(Meta::NameValue(MetaNameValue { |
David Tolnay | bb4ca9f | 2017-12-26 12:28:58 -0500 | [diff] [blame] | 132 | ident: *name, |
David Tolnay | 369f0c5 | 2017-12-27 01:50:45 -0500 | [diff] [blame] | 133 | eq_token: Token, |
David Tolnay | 360efd2 | 2018-01-04 23:35:26 -0800 | [diff] [blame] | 134 | lit: Lit::new(lit.clone(), tts[1].span), |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 135 | })); |
Arnavion | bf395bf | 2017-04-15 15:35:22 -0700 | [diff] [blame] | 136 | } |
Arnavion | bf395bf | 2017-04-15 15:35:22 -0700 | [diff] [blame] | 137 | } |
| 138 | } |
| 139 | |
| 140 | None |
David Tolnay | 02d77cc | 2016-10-02 09:52:08 -0700 | [diff] [blame] | 141 | } |
| 142 | } |
| 143 | |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 144 | fn nested_meta_item_from_tokens(tts: &[TokenTree]) -> Option<(NestedMeta, &[TokenTree])> { |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 145 | assert!(!tts.is_empty()); |
| 146 | |
| 147 | match tts[0].kind { |
Alex Crichton | f9e8f1a | 2017-07-05 18:20:44 -0700 | [diff] [blame] | 148 | TokenNode::Literal(ref lit) => { |
David Tolnay | 360efd2 | 2018-01-04 23:35:26 -0800 | [diff] [blame] | 149 | let lit = Lit::new(lit.clone(), tts[0].span); |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 150 | Some((NestedMeta::Literal(lit), &tts[1..])) |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 151 | } |
| 152 | |
Alex Crichton | f9e8f1a | 2017-07-05 18:20:44 -0700 | [diff] [blame] | 153 | TokenNode::Term(sym) => { |
David Tolnay | eb771d7 | 2017-12-27 22:11:06 -0500 | [diff] [blame] | 154 | let ident = Ident::new(sym.as_str(), tts[0].span); |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 155 | if tts.len() >= 3 { |
Alex Crichton | f9e8f1a | 2017-07-05 18:20:44 -0700 | [diff] [blame] | 156 | if let TokenNode::Op('=', Spacing::Alone) = tts[1].kind { |
| 157 | if let TokenNode::Literal(ref lit) = tts[2].kind { |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 158 | let pair = MetaNameValue { |
David Tolnay | eb771d7 | 2017-12-27 22:11:06 -0500 | [diff] [blame] | 159 | ident: Ident::new(sym.as_str(), tts[0].span), |
David Tolnay | 9894256 | 2017-12-26 21:24:35 -0500 | [diff] [blame] | 160 | eq_token: Token, |
David Tolnay | 360efd2 | 2018-01-04 23:35:26 -0800 | [diff] [blame] | 161 | lit: Lit::new(lit.clone(), tts[2].span), |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 162 | }; |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 163 | return Some((Meta::NameValue(pair).into(), &tts[3..])); |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 164 | } |
| 165 | } |
| 166 | } |
| 167 | |
| 168 | if tts.len() >= 2 { |
Alex Crichton | f9e8f1a | 2017-07-05 18:20:44 -0700 | [diff] [blame] | 169 | if let TokenNode::Group(Delimiter::Parenthesis, ref inner_tts) = tts[1].kind { |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 170 | let inner_tts = inner_tts.clone().into_iter().collect::<Vec<_>>(); |
| 171 | return match list_of_nested_meta_items_from_tokens(&inner_tts) { |
| 172 | Some(nested_meta_items) => { |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 173 | let list = MetaList { |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 174 | ident: ident, |
David Tolnay | 32954ef | 2017-12-26 22:43:16 -0500 | [diff] [blame] | 175 | paren_token: token::Paren(tts[1].span), |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 176 | nested: nested_meta_items, |
| 177 | }; |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 178 | Some((Meta::List(list).into(), &tts[2..])) |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 179 | } |
| 180 | |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 181 | None => None, |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 182 | }; |
| 183 | } |
| 184 | } |
| 185 | |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 186 | Some((Meta::Word(ident).into(), &tts[1..])) |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 187 | } |
| 188 | |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 189 | _ => None, |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 190 | } |
| 191 | } |
| 192 | |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 193 | fn list_of_nested_meta_items_from_tokens( |
| 194 | mut tts: &[TokenTree], |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 195 | ) -> Option<Punctuated<NestedMeta, Token![,]>> { |
David Tolnay | f2cfd72 | 2017-12-31 18:02:51 -0500 | [diff] [blame] | 196 | let mut nested_meta_items = Punctuated::new(); |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 197 | let mut first = true; |
| 198 | |
| 199 | while !tts.is_empty() { |
| 200 | let prev_comma = if first { |
| 201 | first = false; |
| 202 | None |
Alex Crichton | f9e8f1a | 2017-07-05 18:20:44 -0700 | [diff] [blame] | 203 | } else if let TokenNode::Op(',', Spacing::Alone) = tts[0].kind { |
David Tolnay | 9894256 | 2017-12-26 21:24:35 -0500 | [diff] [blame] | 204 | let tok = Token; |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 205 | tts = &tts[1..]; |
| 206 | if tts.is_empty() { |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 207 | break; |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 208 | } |
| 209 | Some(tok) |
| 210 | } else { |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 211 | return None; |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 212 | }; |
| 213 | let (nested, rest) = match nested_meta_item_from_tokens(tts) { |
| 214 | Some(pair) => pair, |
| 215 | None => return None, |
| 216 | }; |
David Tolnay | 660fd1f | 2017-12-31 01:52:57 -0500 | [diff] [blame] | 217 | if let Some(comma) = prev_comma { |
David Tolnay | a0834b4 | 2018-01-01 21:30:02 -0800 | [diff] [blame] | 218 | nested_meta_items.push_punct(comma); |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 219 | } |
David Tolnay | 5608068 | 2018-01-06 14:01:52 -0800 | [diff] [blame] | 220 | nested_meta_items.push_value(nested); |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 221 | tts = rest; |
| 222 | } |
| 223 | |
David Tolnay | f2cfd72 | 2017-12-31 18:02:51 -0500 | [diff] [blame] | 224 | Some(nested_meta_items) |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 225 | } |
| 226 | |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 227 | ast_enum! { |
David Tolnay | 0565850 | 2018-01-07 09:56:37 -0800 | [diff] [blame] | 228 | /// Distinguishes between attributes that decorate an item and attributes |
| 229 | /// that are contained within an item. |
David Tolnay | 2355714 | 2018-01-06 22:45:40 -0800 | [diff] [blame] | 230 | /// |
David Tolnay | 461d98e | 2018-01-07 11:07:19 -0800 | [diff] [blame] | 231 | /// *This type is available if Syn is built with the `"derive"` or `"full"` |
| 232 | /// feature.* |
| 233 | /// |
David Tolnay | 2355714 | 2018-01-06 22:45:40 -0800 | [diff] [blame] | 234 | /// # Outer attributes |
| 235 | /// |
| 236 | /// - `#[repr(transparent)]` |
| 237 | /// - `/// # Example` |
| 238 | /// - `/** Please file an issue */` |
| 239 | /// |
| 240 | /// # Inner attributes |
| 241 | /// |
| 242 | /// - `#![feature(proc_macro)]` |
| 243 | /// - `//! # Example` |
| 244 | /// - `/*! Please file an issue */` |
Alex Crichton | 2e0229c | 2017-05-23 09:34:50 -0700 | [diff] [blame] | 245 | #[cfg_attr(feature = "clone-impls", derive(Copy))] |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 246 | pub enum AttrStyle { |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 247 | Outer, |
David Tolnay | f8db7ba | 2017-11-11 22:52:16 -0800 | [diff] [blame] | 248 | Inner(Token![!]), |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 249 | } |
David Tolnay | 4a51dc7 | 2016-10-01 00:40:31 -0700 | [diff] [blame] | 250 | } |
| 251 | |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 252 | ast_enum_of_structs! { |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 253 | /// Content of a compile-time structured attribute. |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 254 | /// |
David Tolnay | 461d98e | 2018-01-07 11:07:19 -0800 | [diff] [blame] | 255 | /// *This type is available if Syn is built with the `"derive"` or `"full"` |
| 256 | /// feature.* |
| 257 | /// |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 258 | /// ## Word |
| 259 | /// |
| 260 | /// A meta word is like the `test` in `#[test]`. |
| 261 | /// |
| 262 | /// ## List |
| 263 | /// |
| 264 | /// A meta list is like the `derive(Copy)` in `#[derive(Copy)]`. |
| 265 | /// |
| 266 | /// ## NameValue |
| 267 | /// |
| 268 | /// A name-value meta is like the `path = "..."` in `#[path = |
| 269 | /// "sys/windows.rs"]`. |
David Tolnay | 614a014 | 2018-01-07 10:25:43 -0800 | [diff] [blame] | 270 | /// |
| 271 | /// # Syntax tree enum |
| 272 | /// |
| 273 | /// This type is a [syntax tree enum]. |
| 274 | /// |
| 275 | /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 276 | pub enum Meta { |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 277 | pub Word(Ident), |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 278 | /// A structured list within an attribute, like `derive(Copy, Clone)`. |
David Tolnay | 461d98e | 2018-01-07 11:07:19 -0800 | [diff] [blame] | 279 | /// |
| 280 | /// *This type is available if Syn is built with the `"derive"` or |
| 281 | /// `"full"` feature.* |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 282 | pub List(MetaList { |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 283 | pub ident: Ident, |
David Tolnay | 32954ef | 2017-12-26 22:43:16 -0500 | [diff] [blame] | 284 | pub paren_token: token::Paren, |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 285 | pub nested: Punctuated<NestedMeta, Token![,]>, |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 286 | }), |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 287 | /// A name-value pair within an attribute, like `feature = "nightly"`. |
David Tolnay | 461d98e | 2018-01-07 11:07:19 -0800 | [diff] [blame] | 288 | /// |
| 289 | /// *This type is available if Syn is built with the `"derive"` or |
| 290 | /// `"full"` feature.* |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 291 | pub NameValue(MetaNameValue { |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 292 | pub ident: Ident, |
David Tolnay | f8db7ba | 2017-11-11 22:52:16 -0800 | [diff] [blame] | 293 | pub eq_token: Token![=], |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 294 | pub lit: Lit, |
| 295 | }), |
| 296 | } |
Arnavion | 95f8a7a | 2017-04-19 03:29:56 -0700 | [diff] [blame] | 297 | } |
| 298 | |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 299 | impl Meta { |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 300 | /// Returns the identifier that begins this structured meta item. |
Arnavion | 95f8a7a | 2017-04-19 03:29:56 -0700 | [diff] [blame] | 301 | /// |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 302 | /// For example this would return the `test` in `#[test]`, the `derive` in |
| 303 | /// `#[derive(Copy)]`, and the `path` in `#[path = "sys/windows.rs"]`. |
| 304 | pub fn name(&self) -> Ident { |
Arnavion | 95f8a7a | 2017-04-19 03:29:56 -0700 | [diff] [blame] | 305 | match *self { |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 306 | Meta::Word(ref meta) => *meta, |
| 307 | Meta::List(ref meta) => meta.ident, |
| 308 | Meta::NameValue(ref meta) => meta.ident, |
Arnavion | 95f8a7a | 2017-04-19 03:29:56 -0700 | [diff] [blame] | 309 | } |
| 310 | } |
David Tolnay | 8e661e2 | 2016-09-27 00:00:04 -0700 | [diff] [blame] | 311 | } |
| 312 | |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 313 | ast_enum_of_structs! { |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 314 | /// Element of a compile-time attribute list. |
David Tolnay | 461d98e | 2018-01-07 11:07:19 -0800 | [diff] [blame] | 315 | /// |
| 316 | /// *This type is available if Syn is built with the `"derive"` or `"full"` |
| 317 | /// feature.* |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 318 | pub enum NestedMeta { |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 319 | /// A structured meta item, like the `Copy` in `#[derive(Copy)]` which |
| 320 | /// would be a nested `Meta::Word`. |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 321 | pub Meta(Meta), |
Clar Charr | d22b570 | 2017-03-10 15:24:56 -0500 | [diff] [blame] | 322 | |
David Tolnay | 068120a | 2018-01-06 23:17:22 -0800 | [diff] [blame] | 323 | /// A Rust literal, like the `"new_name"` in `#[rename("new_name")]`. |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 324 | pub Literal(Lit), |
| 325 | } |
David Tolnay | b7fa2b6 | 2016-10-30 10:50:47 -0700 | [diff] [blame] | 326 | } |
| 327 | |
David Tolnay | 4a51dc7 | 2016-10-01 00:40:31 -0700 | [diff] [blame] | 328 | pub trait FilterAttrs<'a> { |
| 329 | type Ret: Iterator<Item = &'a Attribute>; |
| 330 | |
| 331 | fn outer(self) -> Self::Ret; |
| 332 | fn inner(self) -> Self::Ret; |
| 333 | } |
| 334 | |
David Tolnay | daaf774 | 2016-10-03 11:11:43 -0700 | [diff] [blame] | 335 | impl<'a, T> FilterAttrs<'a> for T |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 336 | where |
| 337 | T: IntoIterator<Item = &'a Attribute>, |
David Tolnay | daaf774 | 2016-10-03 11:11:43 -0700 | [diff] [blame] | 338 | { |
David Tolnay | 4a51dc7 | 2016-10-01 00:40:31 -0700 | [diff] [blame] | 339 | type Ret = iter::Filter<T::IntoIter, fn(&&Attribute) -> bool>; |
| 340 | |
| 341 | fn outer(self) -> Self::Ret { |
| 342 | fn is_outer(attr: &&Attribute) -> bool { |
Alex Crichton | 2e0229c | 2017-05-23 09:34:50 -0700 | [diff] [blame] | 343 | match attr.style { |
| 344 | AttrStyle::Outer => true, |
| 345 | _ => false, |
| 346 | } |
David Tolnay | 4a51dc7 | 2016-10-01 00:40:31 -0700 | [diff] [blame] | 347 | } |
| 348 | self.into_iter().filter(is_outer) |
| 349 | } |
| 350 | |
| 351 | fn inner(self) -> Self::Ret { |
| 352 | fn is_inner(attr: &&Attribute) -> bool { |
Alex Crichton | 2e0229c | 2017-05-23 09:34:50 -0700 | [diff] [blame] | 353 | match attr.style { |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 354 | AttrStyle::Inner(_) => true, |
Alex Crichton | 2e0229c | 2017-05-23 09:34:50 -0700 | [diff] [blame] | 355 | _ => false, |
| 356 | } |
David Tolnay | 4a51dc7 | 2016-10-01 00:40:31 -0700 | [diff] [blame] | 357 | } |
| 358 | self.into_iter().filter(is_inner) |
| 359 | } |
| 360 | } |
| 361 | |
David Tolnay | 86eca75 | 2016-09-04 11:26:41 -0700 | [diff] [blame] | 362 | #[cfg(feature = "parsing")] |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 363 | pub mod parsing { |
| 364 | use super::*; |
David Tolnay | dfc886b | 2018-01-06 08:03:09 -0800 | [diff] [blame] | 365 | use buffer::Cursor; |
David Tolnay | 203557a | 2017-12-27 23:59:33 -0500 | [diff] [blame] | 366 | use parse_error; |
| 367 | use synom::PResult; |
David Tolnay | 61037c6 | 2018-01-05 16:21:03 -0800 | [diff] [blame] | 368 | use proc_macro2::{Literal, Spacing, Span, TokenNode, TokenTree}; |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 369 | |
David Tolnay | f800fc1 | 2017-12-27 22:08:48 -0500 | [diff] [blame] | 370 | fn eq(span: Span) -> TokenTree { |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 371 | TokenTree { |
David Tolnay | f800fc1 | 2017-12-27 22:08:48 -0500 | [diff] [blame] | 372 | span: span, |
Alex Crichton | f9e8f1a | 2017-07-05 18:20:44 -0700 | [diff] [blame] | 373 | kind: TokenNode::Op('=', Spacing::Alone), |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 374 | } |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 375 | } |
| 376 | |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 377 | impl Attribute { |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 378 | named!(pub parse_inner -> Self, alt!( |
| 379 | do_parse!( |
David Tolnay | f8db7ba | 2017-11-11 22:52:16 -0800 | [diff] [blame] | 380 | pound: punct!(#) >> |
| 381 | bang: punct!(!) >> |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 382 | path_and_tts: brackets!(tuple!( |
David Tolnay | e64213b | 2017-12-30 00:24:20 -0500 | [diff] [blame] | 383 | call!(Path::parse_mod_style), |
David Tolnay | 369f0c5 | 2017-12-27 01:50:45 -0500 | [diff] [blame] | 384 | syn!(TokenStream) |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 385 | )) >> |
| 386 | ({ |
David Tolnay | 8875fca | 2017-12-31 13:52:37 -0500 | [diff] [blame] | 387 | let (bracket, (path, tts)) = path_and_tts; |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 388 | |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 389 | Attribute { |
| 390 | style: AttrStyle::Inner(bang), |
| 391 | path: path, |
| 392 | tts: tts, |
| 393 | is_sugared_doc: false, |
| 394 | pound_token: pound, |
| 395 | bracket_token: bracket, |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 396 | } |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 397 | }) |
| 398 | ) |
| 399 | | |
| 400 | map!( |
David Tolnay | 201ef21 | 2018-01-01 00:09:14 -0500 | [diff] [blame] | 401 | call!(lit_doc_comment, Comment::Inner), |
David Tolnay | f800fc1 | 2017-12-27 22:08:48 -0500 | [diff] [blame] | 402 | |lit| { |
| 403 | let span = lit.span; |
| 404 | Attribute { |
| 405 | style: AttrStyle::Inner(<Token![!]>::new(span)), |
| 406 | path: Ident::new("doc", span).into(), |
| 407 | tts: vec![ |
| 408 | eq(span), |
| 409 | lit, |
| 410 | ].into_iter().collect(), |
| 411 | is_sugared_doc: true, |
| 412 | pound_token: <Token![#]>::new(span), |
| 413 | bracket_token: token::Bracket(span), |
| 414 | } |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 415 | } |
| 416 | ) |
| 417 | )); |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 418 | |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 419 | named!(pub parse_outer -> Self, alt!( |
| 420 | do_parse!( |
David Tolnay | f8db7ba | 2017-11-11 22:52:16 -0800 | [diff] [blame] | 421 | pound: punct!(#) >> |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 422 | path_and_tts: brackets!(tuple!( |
David Tolnay | e64213b | 2017-12-30 00:24:20 -0500 | [diff] [blame] | 423 | call!(Path::parse_mod_style), |
David Tolnay | 369f0c5 | 2017-12-27 01:50:45 -0500 | [diff] [blame] | 424 | syn!(TokenStream) |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 425 | )) >> |
| 426 | ({ |
David Tolnay | 8875fca | 2017-12-31 13:52:37 -0500 | [diff] [blame] | 427 | let (bracket, (path, tts)) = path_and_tts; |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 428 | |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 429 | Attribute { |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 430 | style: AttrStyle::Outer, |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 431 | path: path, |
| 432 | tts: tts, |
| 433 | is_sugared_doc: false, |
| 434 | pound_token: pound, |
| 435 | bracket_token: bracket, |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 436 | } |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 437 | }) |
| 438 | ) |
| 439 | | |
| 440 | map!( |
David Tolnay | 201ef21 | 2018-01-01 00:09:14 -0500 | [diff] [blame] | 441 | call!(lit_doc_comment, Comment::Outer), |
David Tolnay | f800fc1 | 2017-12-27 22:08:48 -0500 | [diff] [blame] | 442 | |lit| { |
| 443 | let span = lit.span; |
| 444 | Attribute { |
| 445 | style: AttrStyle::Outer, |
| 446 | path: Ident::new("doc", span).into(), |
| 447 | tts: vec![ |
| 448 | eq(span), |
| 449 | lit, |
| 450 | ].into_iter().collect(), |
| 451 | is_sugared_doc: true, |
| 452 | pound_token: <Token![#]>::new(span), |
| 453 | bracket_token: token::Bracket(span), |
| 454 | } |
Michael Layzell | 92639a5 | 2017-06-01 00:07:44 -0400 | [diff] [blame] | 455 | } |
| 456 | ) |
| 457 | )); |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 458 | } |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 459 | |
David Tolnay | 201ef21 | 2018-01-01 00:09:14 -0500 | [diff] [blame] | 460 | enum Comment { |
| 461 | Inner, |
| 462 | Outer, |
| 463 | } |
| 464 | |
| 465 | fn lit_doc_comment(input: Cursor, style: Comment) -> PResult<TokenTree> { |
Michael Layzell | 589a8f4 | 2017-06-02 19:47:01 -0400 | [diff] [blame] | 466 | match input.literal() { |
David Tolnay | 6572948 | 2017-12-31 16:14:50 -0500 | [diff] [blame] | 467 | Some((span, lit, rest)) => { |
David Tolnay | 201ef21 | 2018-01-01 00:09:14 -0500 | [diff] [blame] | 468 | let string = lit.to_string(); |
| 469 | let ok = match style { |
David Tolnay | 61037c6 | 2018-01-05 16:21:03 -0800 | [diff] [blame] | 470 | Comment::Inner => string.starts_with("//!") || string.starts_with("/*!"), |
| 471 | Comment::Outer => string.starts_with("///") || string.starts_with("/**"), |
David Tolnay | 201ef21 | 2018-01-01 00:09:14 -0500 | [diff] [blame] | 472 | }; |
| 473 | if ok { |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 474 | Ok(( |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 475 | TokenTree { |
| 476 | span: span, |
David Tolnay | 360efd2 | 2018-01-04 23:35:26 -0800 | [diff] [blame] | 477 | kind: TokenNode::Literal(Literal::string(&string)), |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 478 | }, |
David Tolnay | f4aa6b4 | 2017-12-31 16:40:33 -0500 | [diff] [blame] | 479 | rest, |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 480 | )) |
Michael Layzell | 589a8f4 | 2017-06-02 19:47:01 -0400 | [diff] [blame] | 481 | } else { |
| 482 | parse_error() |
| 483 | } |
| 484 | } |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 485 | _ => parse_error(), |
Alex Crichton | 954046c | 2017-05-30 21:49:42 -0700 | [diff] [blame] | 486 | } |
| 487 | } |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 488 | } |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 489 | |
| 490 | #[cfg(feature = "printing")] |
| 491 | mod printing { |
| 492 | use super::*; |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 493 | use quote::{ToTokens, Tokens}; |
David Tolnay | 360efd2 | 2018-01-04 23:35:26 -0800 | [diff] [blame] | 494 | use proc_macro2::Literal; |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 495 | |
| 496 | impl ToTokens for Attribute { |
| 497 | fn to_tokens(&self, tokens: &mut Tokens) { |
Arnavion | 44d2bf3 | 2017-04-19 02:47:55 -0700 | [diff] [blame] | 498 | // If this was a sugared doc, emit it in its original form instead of `#[doc = "..."]` |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 499 | if self.is_sugared_doc { |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 500 | if let Some(Meta::NameValue(ref pair)) = self.interpret_meta() { |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 501 | if pair.ident == "doc" { |
David Tolnay | 360efd2 | 2018-01-04 23:35:26 -0800 | [diff] [blame] | 502 | if let Lit::Str(ref comment) = pair.lit { |
| 503 | tokens.append(TokenTree { |
| 504 | span: comment.span, |
| 505 | kind: TokenNode::Literal(Literal::doccomment(&comment.value())), |
| 506 | }); |
David Tolnay | 5138205 | 2017-12-27 13:46:21 -0500 | [diff] [blame] | 507 | return; |
David Tolnay | 14cbdeb | 2016-10-01 12:13:59 -0700 | [diff] [blame] | 508 | } |
David Tolnay | 4a51dc7 | 2016-10-01 00:40:31 -0700 | [diff] [blame] | 509 | } |
David Tolnay | c91dd67 | 2016-10-01 01:03:56 -0700 | [diff] [blame] | 510 | } |
| 511 | } |
David Tolnay | 14cbdeb | 2016-10-01 12:13:59 -0700 | [diff] [blame] | 512 | |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 513 | self.pound_token.to_tokens(tokens); |
| 514 | if let AttrStyle::Inner(ref b) = self.style { |
| 515 | b.to_tokens(tokens); |
David Tolnay | 14cbdeb | 2016-10-01 12:13:59 -0700 | [diff] [blame] | 516 | } |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 517 | self.bracket_token.surround(tokens, |tokens| { |
| 518 | self.path.to_tokens(tokens); |
David Tolnay | 360efd2 | 2018-01-04 23:35:26 -0800 | [diff] [blame] | 519 | self.tts.to_tokens(tokens); |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 520 | }); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 521 | } |
| 522 | } |
| 523 | |
David Tolnay | aaadd78 | 2018-01-06 22:58:13 -0800 | [diff] [blame] | 524 | impl ToTokens for MetaList { |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 525 | fn to_tokens(&self, tokens: &mut Tokens) { |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 526 | self.ident.to_tokens(tokens); |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 527 | self.paren_token.surround(tokens, |tokens| { |
| 528 | self.nested.to_tokens(tokens); |
| 529 | }) |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 530 | } |
| 531 | } |
David Tolnay | b7fa2b6 | 2016-10-30 10:50:47 -0700 | [diff] [blame] | 532 | |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 533 | impl ToTokens for MetaNameValue { |
David Tolnay | b7fa2b6 | 2016-10-30 10:50:47 -0700 | [diff] [blame] | 534 | fn to_tokens(&self, tokens: &mut Tokens) { |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 535 | self.ident.to_tokens(tokens); |
Alex Crichton | ccbb45d | 2017-05-23 10:58:24 -0700 | [diff] [blame] | 536 | self.eq_token.to_tokens(tokens); |
Alex Crichton | 62a0a59 | 2017-05-22 13:58:53 -0700 | [diff] [blame] | 537 | self.lit.to_tokens(tokens); |
David Tolnay | b7fa2b6 | 2016-10-30 10:50:47 -0700 | [diff] [blame] | 538 | } |
| 539 | } |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 540 | } |