blob: 06af8a5f4f1906a19d0e5328fbb37cb8c2abe702 [file] [log] [blame]
David Tolnay55535012018-01-05 16:39:23 -08001// 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 Tolnayb79ee962016-09-04 09:39:20 -07009use super::*;
David Tolnayf2cfd722017-12-31 18:02:51 -050010use punctuated::Punctuated;
David Tolnayb79ee962016-09-04 09:39:20 -070011
David Tolnay4a51dc72016-10-01 00:40:31 -070012use std::iter;
13
David Tolnay51382052017-12-27 13:46:21 -050014use proc_macro2::{Delimiter, Spacing, TokenNode, TokenStream, TokenTree};
David Tolnay9c76bcb2017-12-26 23:14:59 -050015
16#[cfg(feature = "extra-traits")]
17use std::hash::{Hash, Hasher};
18#[cfg(feature = "extra-traits")]
David Tolnayc43b44e2017-12-30 23:55:54 -050019use tt::TokenStreamHelper;
Alex Crichtonccbb45d2017-05-23 10:58:24 -070020
Alex Crichton62a0a592017-05-22 13:58:53 -070021ast_struct! {
David Tolnay23557142018-01-06 22:45:40 -080022 /// An attribute like `#[repr(transparent)]`.
23 ///
David Tolnay461d98e2018-01-07 11:07:19 -080024 /// *This type is available if Syn is built with the `"derive"` or `"full"`
25 /// feature.*
26 ///
David Tolnay23557142018-01-06 22:45:40 -080027 /// # 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 Tolnay068120a2018-01-06 23:17:22 -080056 /// 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 Tolnay23557142018-01-06 22:45:40 -080059 ///
David Tolnay068120a2018-01-06 23:17:22 -080060 /// [`interpret_meta`]: #method.interpret_meta
David Tolnay9c76bcb2017-12-26 23:14:59 -050061 pub struct Attribute #manual_extra_traits {
David Tolnayf8db7ba2017-11-11 22:52:16 -080062 pub pound_token: Token![#],
David Tolnay4a3f59a2017-12-28 21:21:12 -050063 pub style: AttrStyle,
David Tolnay32954ef2017-12-26 22:43:16 -050064 pub bracket_token: token::Bracket,
Alex Crichton62a0a592017-05-22 13:58:53 -070065 pub path: Path,
David Tolnay369f0c52017-12-27 01:50:45 -050066 pub tts: TokenStream,
Alex Crichton62a0a592017-05-22 13:58:53 -070067 pub is_sugared_doc: bool,
68 }
David Tolnayb79ee962016-09-04 09:39:20 -070069}
70
David Tolnay9c76bcb2017-12-26 23:14:59 -050071#[cfg(feature = "extra-traits")]
72impl Eq for Attribute {}
73
74#[cfg(feature = "extra-traits")]
75impl PartialEq for Attribute {
76 fn eq(&self, other: &Self) -> bool {
David Tolnay51382052017-12-27 13:46:21 -050077 self.style == other.style && self.pound_token == other.pound_token
78 && self.bracket_token == other.bracket_token && self.path == other.path
David Tolnay369f0c52017-12-27 01:50:45 -050079 && TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
David Tolnay9c76bcb2017-12-26 23:14:59 -050080 && self.is_sugared_doc == other.is_sugared_doc
81 }
82}
83
84#[cfg(feature = "extra-traits")]
85impl Hash for Attribute {
86 fn hash<H>(&self, state: &mut H)
David Tolnay51382052017-12-27 13:46:21 -050087 where
88 H: Hasher,
David Tolnay9c76bcb2017-12-26 23:14:59 -050089 {
90 self.style.hash(state);
91 self.pound_token.hash(state);
92 self.bracket_token.hash(state);
93 self.path.hash(state);
David Tolnay369f0c52017-12-27 01:50:45 -050094 TokenStreamHelper(&self.tts).hash(state);
David Tolnay9c76bcb2017-12-26 23:14:59 -050095 self.is_sugared_doc.hash(state);
96 }
97}
98
David Tolnay02d77cc2016-10-02 09:52:08 -070099impl Attribute {
David Tolnay068120a2018-01-06 23:17:22 -0800100 /// Parses the tokens after the path as a [`Meta`](enum.Meta.html) if
101 /// possible.
David Tolnayaaadd782018-01-06 22:58:13 -0800102 pub fn interpret_meta(&self) -> Option<Meta> {
Arnavion95f8a7a2017-04-19 03:29:56 -0700103 let name = if self.path.segments.len() == 1 {
David Tolnay56080682018-01-06 14:01:52 -0800104 &self.path.segments.first().unwrap().value().ident
Arnavion95f8a7a2017-04-19 03:29:56 -0700105 } else {
106 return None;
107 };
108
Arnavionbf395bf2017-04-15 15:35:22 -0700109 if self.tts.is_empty() {
David Tolnayaaadd782018-01-06 22:58:13 -0800110 return Some(Meta::Word(*name));
Arnavionbf395bf2017-04-15 15:35:22 -0700111 }
112
David Tolnay369f0c52017-12-27 01:50:45 -0500113 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 Crichtonccbb45d2017-05-23 10:58:24 -0700117 let tokens = ts.clone().into_iter().collect::<Vec<_>>();
118 if let Some(nested_meta_items) = list_of_nested_meta_items_from_tokens(&tokens) {
David Tolnayaaadd782018-01-06 22:58:13 -0800119 return Some(Meta::List(MetaList {
David Tolnay369f0c52017-12-27 01:50:45 -0500120 paren_token: token::Paren(tts[0].span),
David Tolnaybb4ca9f2017-12-26 12:28:58 -0500121 ident: *name,
Alex Crichton62a0a592017-05-22 13:58:53 -0700122 nested: nested_meta_items,
123 }));
Arnavionbf395bf2017-04-15 15:35:22 -0700124 }
125 }
126 }
127
David Tolnay369f0c52017-12-27 01:50:45 -0500128 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 Tolnayaaadd782018-01-06 22:58:13 -0800131 return Some(Meta::NameValue(MetaNameValue {
David Tolnaybb4ca9f2017-12-26 12:28:58 -0500132 ident: *name,
David Tolnay369f0c52017-12-27 01:50:45 -0500133 eq_token: Token![=]([tts[0].span]),
David Tolnay360efd22018-01-04 23:35:26 -0800134 lit: Lit::new(lit.clone(), tts[1].span),
Alex Crichton62a0a592017-05-22 13:58:53 -0700135 }));
Arnavionbf395bf2017-04-15 15:35:22 -0700136 }
Arnavionbf395bf2017-04-15 15:35:22 -0700137 }
138 }
139
140 None
David Tolnay02d77cc2016-10-02 09:52:08 -0700141 }
142}
143
David Tolnayaaadd782018-01-06 22:58:13 -0800144fn nested_meta_item_from_tokens(tts: &[TokenTree]) -> Option<(NestedMeta, &[TokenTree])> {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700145 assert!(!tts.is_empty());
146
147 match tts[0].kind {
Alex Crichtonf9e8f1a2017-07-05 18:20:44 -0700148 TokenNode::Literal(ref lit) => {
David Tolnay360efd22018-01-04 23:35:26 -0800149 let lit = Lit::new(lit.clone(), tts[0].span);
David Tolnayaaadd782018-01-06 22:58:13 -0800150 Some((NestedMeta::Literal(lit), &tts[1..]))
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700151 }
152
Alex Crichtonf9e8f1a2017-07-05 18:20:44 -0700153 TokenNode::Term(sym) => {
David Tolnayeb771d72017-12-27 22:11:06 -0500154 let ident = Ident::new(sym.as_str(), tts[0].span);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700155 if tts.len() >= 3 {
Alex Crichtonf9e8f1a2017-07-05 18:20:44 -0700156 if let TokenNode::Op('=', Spacing::Alone) = tts[1].kind {
157 if let TokenNode::Literal(ref lit) = tts[2].kind {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700158 let pair = MetaNameValue {
David Tolnayeb771d72017-12-27 22:11:06 -0500159 ident: Ident::new(sym.as_str(), tts[0].span),
David Tolnay98942562017-12-26 21:24:35 -0500160 eq_token: Token![=]([tts[1].span]),
David Tolnay360efd22018-01-04 23:35:26 -0800161 lit: Lit::new(lit.clone(), tts[2].span),
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700162 };
David Tolnayaaadd782018-01-06 22:58:13 -0800163 return Some((Meta::NameValue(pair).into(), &tts[3..]));
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700164 }
165 }
166 }
167
168 if tts.len() >= 2 {
Alex Crichtonf9e8f1a2017-07-05 18:20:44 -0700169 if let TokenNode::Group(Delimiter::Parenthesis, ref inner_tts) = tts[1].kind {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700170 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 Tolnayaaadd782018-01-06 22:58:13 -0800173 let list = MetaList {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700174 ident: ident,
David Tolnay32954ef2017-12-26 22:43:16 -0500175 paren_token: token::Paren(tts[1].span),
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700176 nested: nested_meta_items,
177 };
David Tolnayaaadd782018-01-06 22:58:13 -0800178 Some((Meta::List(list).into(), &tts[2..]))
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700179 }
180
David Tolnay51382052017-12-27 13:46:21 -0500181 None => None,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700182 };
183 }
184 }
185
David Tolnayaaadd782018-01-06 22:58:13 -0800186 Some((Meta::Word(ident).into(), &tts[1..]))
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700187 }
188
David Tolnay51382052017-12-27 13:46:21 -0500189 _ => None,
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700190 }
191}
192
David Tolnay51382052017-12-27 13:46:21 -0500193fn list_of_nested_meta_items_from_tokens(
194 mut tts: &[TokenTree],
David Tolnayaaadd782018-01-06 22:58:13 -0800195) -> Option<Punctuated<NestedMeta, Token![,]>> {
David Tolnayf2cfd722017-12-31 18:02:51 -0500196 let mut nested_meta_items = Punctuated::new();
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700197 let mut first = true;
198
199 while !tts.is_empty() {
200 let prev_comma = if first {
201 first = false;
202 None
Alex Crichtonf9e8f1a2017-07-05 18:20:44 -0700203 } else if let TokenNode::Op(',', Spacing::Alone) = tts[0].kind {
David Tolnay98942562017-12-26 21:24:35 -0500204 let tok = Token![,]([tts[0].span]);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700205 tts = &tts[1..];
206 if tts.is_empty() {
David Tolnay51382052017-12-27 13:46:21 -0500207 break;
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700208 }
209 Some(tok)
210 } else {
David Tolnay51382052017-12-27 13:46:21 -0500211 return None;
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700212 };
213 let (nested, rest) = match nested_meta_item_from_tokens(tts) {
214 Some(pair) => pair,
215 None => return None,
216 };
David Tolnay660fd1f2017-12-31 01:52:57 -0500217 if let Some(comma) = prev_comma {
David Tolnaya0834b42018-01-01 21:30:02 -0800218 nested_meta_items.push_punct(comma);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700219 }
David Tolnay56080682018-01-06 14:01:52 -0800220 nested_meta_items.push_value(nested);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700221 tts = rest;
222 }
223
David Tolnayf2cfd722017-12-31 18:02:51 -0500224 Some(nested_meta_items)
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700225}
226
Alex Crichton62a0a592017-05-22 13:58:53 -0700227ast_enum! {
David Tolnay05658502018-01-07 09:56:37 -0800228 /// Distinguishes between attributes that decorate an item and attributes
229 /// that are contained within an item.
David Tolnay23557142018-01-06 22:45:40 -0800230 ///
David Tolnay461d98e2018-01-07 11:07:19 -0800231 /// *This type is available if Syn is built with the `"derive"` or `"full"`
232 /// feature.*
233 ///
David Tolnay23557142018-01-06 22:45:40 -0800234 /// # 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 Crichton2e0229c2017-05-23 09:34:50 -0700245 #[cfg_attr(feature = "clone-impls", derive(Copy))]
Alex Crichton62a0a592017-05-22 13:58:53 -0700246 pub enum AttrStyle {
Alex Crichton62a0a592017-05-22 13:58:53 -0700247 Outer,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800248 Inner(Token![!]),
Alex Crichton62a0a592017-05-22 13:58:53 -0700249 }
David Tolnay4a51dc72016-10-01 00:40:31 -0700250}
251
Alex Crichton62a0a592017-05-22 13:58:53 -0700252ast_enum_of_structs! {
David Tolnay068120a2018-01-06 23:17:22 -0800253 /// Content of a compile-time structured attribute.
David Tolnayb79ee962016-09-04 09:39:20 -0700254 ///
David Tolnay461d98e2018-01-07 11:07:19 -0800255 /// *This type is available if Syn is built with the `"derive"` or `"full"`
256 /// feature.*
257 ///
David Tolnay068120a2018-01-06 23:17:22 -0800258 /// ## 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 Tolnay614a0142018-01-07 10:25:43 -0800270 ///
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 Tolnayaaadd782018-01-06 22:58:13 -0800276 pub enum Meta {
David Tolnayaaadd782018-01-06 22:58:13 -0800277 pub Word(Ident),
David Tolnay068120a2018-01-06 23:17:22 -0800278 /// A structured list within an attribute, like `derive(Copy, Clone)`.
David Tolnay461d98e2018-01-07 11:07:19 -0800279 ///
280 /// *This type is available if Syn is built with the `"derive"` or
281 /// `"full"` feature.*
David Tolnayaaadd782018-01-06 22:58:13 -0800282 pub List(MetaList {
Alex Crichton62a0a592017-05-22 13:58:53 -0700283 pub ident: Ident,
David Tolnay32954ef2017-12-26 22:43:16 -0500284 pub paren_token: token::Paren,
David Tolnayaaadd782018-01-06 22:58:13 -0800285 pub nested: Punctuated<NestedMeta, Token![,]>,
Alex Crichton62a0a592017-05-22 13:58:53 -0700286 }),
David Tolnay068120a2018-01-06 23:17:22 -0800287 /// A name-value pair within an attribute, like `feature = "nightly"`.
David Tolnay461d98e2018-01-07 11:07:19 -0800288 ///
289 /// *This type is available if Syn is built with the `"derive"` or
290 /// `"full"` feature.*
Alex Crichton62a0a592017-05-22 13:58:53 -0700291 pub NameValue(MetaNameValue {
Alex Crichton62a0a592017-05-22 13:58:53 -0700292 pub ident: Ident,
David Tolnayf8db7ba2017-11-11 22:52:16 -0800293 pub eq_token: Token![=],
Alex Crichton62a0a592017-05-22 13:58:53 -0700294 pub lit: Lit,
295 }),
296 }
Arnavion95f8a7a2017-04-19 03:29:56 -0700297}
298
David Tolnayaaadd782018-01-06 22:58:13 -0800299impl Meta {
David Tolnay068120a2018-01-06 23:17:22 -0800300 /// Returns the identifier that begins this structured meta item.
Arnavion95f8a7a2017-04-19 03:29:56 -0700301 ///
David Tolnay068120a2018-01-06 23:17:22 -0800302 /// 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 {
Arnavion95f8a7a2017-04-19 03:29:56 -0700305 match *self {
David Tolnay068120a2018-01-06 23:17:22 -0800306 Meta::Word(ref meta) => *meta,
307 Meta::List(ref meta) => meta.ident,
308 Meta::NameValue(ref meta) => meta.ident,
Arnavion95f8a7a2017-04-19 03:29:56 -0700309 }
310 }
David Tolnay8e661e22016-09-27 00:00:04 -0700311}
312
Alex Crichton62a0a592017-05-22 13:58:53 -0700313ast_enum_of_structs! {
David Tolnay068120a2018-01-06 23:17:22 -0800314 /// Element of a compile-time attribute list.
David Tolnay461d98e2018-01-07 11:07:19 -0800315 ///
316 /// *This type is available if Syn is built with the `"derive"` or `"full"`
317 /// feature.*
David Tolnayaaadd782018-01-06 22:58:13 -0800318 pub enum NestedMeta {
David Tolnay068120a2018-01-06 23:17:22 -0800319 /// A structured meta item, like the `Copy` in `#[derive(Copy)]` which
320 /// would be a nested `Meta::Word`.
David Tolnayaaadd782018-01-06 22:58:13 -0800321 pub Meta(Meta),
Clar Charrd22b5702017-03-10 15:24:56 -0500322
David Tolnay068120a2018-01-06 23:17:22 -0800323 /// A Rust literal, like the `"new_name"` in `#[rename("new_name")]`.
Alex Crichton62a0a592017-05-22 13:58:53 -0700324 pub Literal(Lit),
325 }
David Tolnayb7fa2b62016-10-30 10:50:47 -0700326}
327
David Tolnay4a51dc72016-10-01 00:40:31 -0700328pub 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 Tolnaydaaf7742016-10-03 11:11:43 -0700335impl<'a, T> FilterAttrs<'a> for T
David Tolnay51382052017-12-27 13:46:21 -0500336where
337 T: IntoIterator<Item = &'a Attribute>,
David Tolnaydaaf7742016-10-03 11:11:43 -0700338{
David Tolnay4a51dc72016-10-01 00:40:31 -0700339 type Ret = iter::Filter<T::IntoIter, fn(&&Attribute) -> bool>;
340
341 fn outer(self) -> Self::Ret {
342 fn is_outer(attr: &&Attribute) -> bool {
Alex Crichton2e0229c2017-05-23 09:34:50 -0700343 match attr.style {
344 AttrStyle::Outer => true,
345 _ => false,
346 }
David Tolnay4a51dc72016-10-01 00:40:31 -0700347 }
348 self.into_iter().filter(is_outer)
349 }
350
351 fn inner(self) -> Self::Ret {
352 fn is_inner(attr: &&Attribute) -> bool {
Alex Crichton2e0229c2017-05-23 09:34:50 -0700353 match attr.style {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700354 AttrStyle::Inner(_) => true,
Alex Crichton2e0229c2017-05-23 09:34:50 -0700355 _ => false,
356 }
David Tolnay4a51dc72016-10-01 00:40:31 -0700357 }
358 self.into_iter().filter(is_inner)
359 }
360}
361
David Tolnay86eca752016-09-04 11:26:41 -0700362#[cfg(feature = "parsing")]
David Tolnay9d8f1972016-09-04 11:58:48 -0700363pub mod parsing {
364 use super::*;
David Tolnaydfc886b2018-01-06 08:03:09 -0800365 use buffer::Cursor;
David Tolnay203557a2017-12-27 23:59:33 -0500366 use parse_error;
367 use synom::PResult;
David Tolnay61037c62018-01-05 16:21:03 -0800368 use proc_macro2::{Literal, Spacing, Span, TokenNode, TokenTree};
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700369
David Tolnayf800fc12017-12-27 22:08:48 -0500370 fn eq(span: Span) -> TokenTree {
Alex Crichton954046c2017-05-30 21:49:42 -0700371 TokenTree {
David Tolnayf800fc12017-12-27 22:08:48 -0500372 span: span,
Alex Crichtonf9e8f1a2017-07-05 18:20:44 -0700373 kind: TokenNode::Op('=', Spacing::Alone),
Alex Crichton954046c2017-05-30 21:49:42 -0700374 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700375 }
376
Alex Crichton954046c2017-05-30 21:49:42 -0700377 impl Attribute {
Michael Layzell92639a52017-06-01 00:07:44 -0400378 named!(pub parse_inner -> Self, alt!(
379 do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800380 pound: punct!(#) >>
381 bang: punct!(!) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400382 path_and_tts: brackets!(tuple!(
David Tolnaye64213b2017-12-30 00:24:20 -0500383 call!(Path::parse_mod_style),
David Tolnay369f0c52017-12-27 01:50:45 -0500384 syn!(TokenStream)
Michael Layzell92639a52017-06-01 00:07:44 -0400385 )) >>
386 ({
David Tolnay8875fca2017-12-31 13:52:37 -0500387 let (bracket, (path, tts)) = path_and_tts;
Alex Crichton954046c2017-05-30 21:49:42 -0700388
Michael Layzell92639a52017-06-01 00:07:44 -0400389 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 Crichton954046c2017-05-30 21:49:42 -0700396 }
Michael Layzell92639a52017-06-01 00:07:44 -0400397 })
398 )
399 |
400 map!(
David Tolnay201ef212018-01-01 00:09:14 -0500401 call!(lit_doc_comment, Comment::Inner),
David Tolnayf800fc12017-12-27 22:08:48 -0500402 |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 Layzell92639a52017-06-01 00:07:44 -0400415 }
416 )
417 ));
Alex Crichton954046c2017-05-30 21:49:42 -0700418
Michael Layzell92639a52017-06-01 00:07:44 -0400419 named!(pub parse_outer -> Self, alt!(
420 do_parse!(
David Tolnayf8db7ba2017-11-11 22:52:16 -0800421 pound: punct!(#) >>
Michael Layzell92639a52017-06-01 00:07:44 -0400422 path_and_tts: brackets!(tuple!(
David Tolnaye64213b2017-12-30 00:24:20 -0500423 call!(Path::parse_mod_style),
David Tolnay369f0c52017-12-27 01:50:45 -0500424 syn!(TokenStream)
Michael Layzell92639a52017-06-01 00:07:44 -0400425 )) >>
426 ({
David Tolnay8875fca2017-12-31 13:52:37 -0500427 let (bracket, (path, tts)) = path_and_tts;
Alex Crichton954046c2017-05-30 21:49:42 -0700428
Michael Layzell92639a52017-06-01 00:07:44 -0400429 Attribute {
Alex Crichton954046c2017-05-30 21:49:42 -0700430 style: AttrStyle::Outer,
Michael Layzell92639a52017-06-01 00:07:44 -0400431 path: path,
432 tts: tts,
433 is_sugared_doc: false,
434 pound_token: pound,
435 bracket_token: bracket,
Alex Crichton954046c2017-05-30 21:49:42 -0700436 }
Michael Layzell92639a52017-06-01 00:07:44 -0400437 })
438 )
439 |
440 map!(
David Tolnay201ef212018-01-01 00:09:14 -0500441 call!(lit_doc_comment, Comment::Outer),
David Tolnayf800fc12017-12-27 22:08:48 -0500442 |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 Layzell92639a52017-06-01 00:07:44 -0400455 }
456 )
457 ));
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700458 }
David Tolnayb79ee962016-09-04 09:39:20 -0700459
David Tolnay201ef212018-01-01 00:09:14 -0500460 enum Comment {
461 Inner,
462 Outer,
463 }
464
465 fn lit_doc_comment(input: Cursor, style: Comment) -> PResult<TokenTree> {
Michael Layzell589a8f42017-06-02 19:47:01 -0400466 match input.literal() {
David Tolnay65729482017-12-31 16:14:50 -0500467 Some((span, lit, rest)) => {
David Tolnay201ef212018-01-01 00:09:14 -0500468 let string = lit.to_string();
469 let ok = match style {
David Tolnay61037c62018-01-05 16:21:03 -0800470 Comment::Inner => string.starts_with("//!") || string.starts_with("/*!"),
471 Comment::Outer => string.starts_with("///") || string.starts_with("/**"),
David Tolnay201ef212018-01-01 00:09:14 -0500472 };
473 if ok {
David Tolnay51382052017-12-27 13:46:21 -0500474 Ok((
David Tolnay51382052017-12-27 13:46:21 -0500475 TokenTree {
476 span: span,
David Tolnay360efd22018-01-04 23:35:26 -0800477 kind: TokenNode::Literal(Literal::string(&string)),
David Tolnay51382052017-12-27 13:46:21 -0500478 },
David Tolnayf4aa6b42017-12-31 16:40:33 -0500479 rest,
David Tolnay51382052017-12-27 13:46:21 -0500480 ))
Michael Layzell589a8f42017-06-02 19:47:01 -0400481 } else {
482 parse_error()
483 }
484 }
David Tolnay51382052017-12-27 13:46:21 -0500485 _ => parse_error(),
Alex Crichton954046c2017-05-30 21:49:42 -0700486 }
487 }
David Tolnay9d8f1972016-09-04 11:58:48 -0700488}
David Tolnay87d0b442016-09-04 11:52:12 -0700489
490#[cfg(feature = "printing")]
491mod printing {
492 use super::*;
David Tolnay51382052017-12-27 13:46:21 -0500493 use quote::{ToTokens, Tokens};
David Tolnay360efd22018-01-04 23:35:26 -0800494 use proc_macro2::Literal;
David Tolnay87d0b442016-09-04 11:52:12 -0700495
496 impl ToTokens for Attribute {
497 fn to_tokens(&self, tokens: &mut Tokens) {
Arnavion44d2bf32017-04-19 02:47:55 -0700498 // If this was a sugared doc, emit it in its original form instead of `#[doc = "..."]`
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700499 if self.is_sugared_doc {
David Tolnayaaadd782018-01-06 22:58:13 -0800500 if let Some(Meta::NameValue(ref pair)) = self.interpret_meta() {
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700501 if pair.ident == "doc" {
David Tolnay360efd22018-01-04 23:35:26 -0800502 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 Tolnay51382052017-12-27 13:46:21 -0500507 return;
David Tolnay14cbdeb2016-10-01 12:13:59 -0700508 }
David Tolnay4a51dc72016-10-01 00:40:31 -0700509 }
David Tolnayc91dd672016-10-01 01:03:56 -0700510 }
511 }
David Tolnay14cbdeb2016-10-01 12:13:59 -0700512
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700513 self.pound_token.to_tokens(tokens);
514 if let AttrStyle::Inner(ref b) = self.style {
515 b.to_tokens(tokens);
David Tolnay14cbdeb2016-10-01 12:13:59 -0700516 }
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700517 self.bracket_token.surround(tokens, |tokens| {
518 self.path.to_tokens(tokens);
David Tolnay360efd22018-01-04 23:35:26 -0800519 self.tts.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700520 });
David Tolnay87d0b442016-09-04 11:52:12 -0700521 }
522 }
523
David Tolnayaaadd782018-01-06 22:58:13 -0800524 impl ToTokens for MetaList {
David Tolnay87d0b442016-09-04 11:52:12 -0700525 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichton62a0a592017-05-22 13:58:53 -0700526 self.ident.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700527 self.paren_token.surround(tokens, |tokens| {
528 self.nested.to_tokens(tokens);
529 })
David Tolnay87d0b442016-09-04 11:52:12 -0700530 }
531 }
David Tolnayb7fa2b62016-10-30 10:50:47 -0700532
Alex Crichton62a0a592017-05-22 13:58:53 -0700533 impl ToTokens for MetaNameValue {
David Tolnayb7fa2b62016-10-30 10:50:47 -0700534 fn to_tokens(&self, tokens: &mut Tokens) {
Alex Crichton62a0a592017-05-22 13:58:53 -0700535 self.ident.to_tokens(tokens);
Alex Crichtonccbb45d2017-05-23 10:58:24 -0700536 self.eq_token.to_tokens(tokens);
Alex Crichton62a0a592017-05-22 13:58:53 -0700537 self.lit.to_tokens(tokens);
David Tolnayb7fa2b62016-10-30 10:50:47 -0700538 }
539 }
David Tolnay87d0b442016-09-04 11:52:12 -0700540}