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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
|
use proc_macro::{Delimiter, Span, TokenStream, TokenTree};
use std::iter;
use std::str::FromStr;
pub fn is_pasted_doc(input: &TokenStream) -> bool {
#[derive(PartialEq)]
enum State {
Init,
Doc,
Equal,
First,
Rest,
}
let mut state = State::Init;
for tt in input.clone() {
state = match (state, &tt) {
(State::Init, TokenTree::Ident(ident)) if ident.to_string() == "doc" => State::Doc,
(State::Doc, TokenTree::Punct(punct)) if punct.as_char() == '=' => State::Equal,
(State::Equal, tt) if is_stringlike(tt) => State::First,
(State::First, tt) | (State::Rest, tt) if is_stringlike(tt) => State::Rest,
_ => return false,
};
}
state == State::Rest
}
pub fn do_paste_doc(attr: &TokenStream, span: Span) -> TokenStream {
let mut expanded = TokenStream::new();
let mut tokens = attr.clone().into_iter();
expanded.extend(tokens.by_ref().take(2)); // `doc =`
let mut lit = String::new();
lit.push('"');
for token in tokens {
lit += &escaped_string_value(&token).unwrap();
}
lit.push('"');
let mut lit = TokenStream::from_str(&lit)
.unwrap()
.into_iter()
.next()
.unwrap();
lit.set_span(span);
expanded.extend(iter::once(lit));
expanded
}
fn is_stringlike(token: &TokenTree) -> bool {
escaped_string_value(token).is_some()
}
fn escaped_string_value(token: &TokenTree) -> Option<String> {
match token {
TokenTree::Ident(ident) => Some(ident.to_string()),
TokenTree::Literal(literal) => {
let mut repr = literal.to_string();
if repr.starts_with('b') || repr.starts_with('\'') {
None
} else if repr.starts_with('"') {
repr.truncate(repr.len() - 1);
repr.remove(0);
Some(repr)
} else if repr.starts_with('r') {
let begin = repr.find('"').unwrap() + 1;
let end = repr.rfind('"').unwrap();
let mut escaped = String::new();
for ch in repr[begin..end].chars() {
escaped.extend(ch.escape_default());
}
Some(escaped)
} else {
Some(repr)
}
}
TokenTree::Group(group) => {
if group.delimiter() != Delimiter::None {
return None;
}
let mut inner = group.stream().into_iter();
let first = inner.next()?;
if inner.next().is_none() {
escaped_string_value(&first)
} else {
None
}
}
TokenTree::Punct(_) => None,
}
}
|
