Skip to main content

pastey/
segment.rs

1use crate::error::{Error, Result};
2use proc_macro::{token_stream, Delimiter, Group, Ident, Literal, Span, TokenTree};
3use std::iter::Peekable;
4
5pub(crate) enum Segment {
6    String(LitStr),
7    Apostrophe(Span),
8    Env(LitStr),
9    Modifier(Colon, Ident),
10    Replace(Colon, Group),
11}
12
13pub(crate) struct LitStr {
14    pub value: String,
15    pub span: Span,
16}
17
18pub(crate) struct Colon {
19    pub span: Span,
20}
21
22pub(crate) fn parse(tokens: &mut Peekable<token_stream::IntoIter>) -> Result<Vec<Segment>> {
23    let mut segments = Vec::new();
24    while match tokens.peek() {
25        None => false,
26        Some(TokenTree::Punct(punct)) => punct.as_char() != '>',
27        Some(_) => true,
28    } {
29        match tokens.next().unwrap() {
30            TokenTree::Ident(ident) => {
31                let mut fragment = ident.to_string();
32                if fragment.starts_with("r#") {
33                    fragment = fragment.split_off(2);
34                }
35                if fragment == "env"
36                    && match tokens.peek() {
37                        Some(TokenTree::Punct(punct)) => punct.as_char() == '!',
38                        _ => false,
39                    }
40                {
41                    let bang = tokens.next().unwrap(); // `!`
42                    let expect_group = tokens.next();
43                    let parenthesized = match &expect_group {
44                        Some(TokenTree::Group(group))
45                            if group.delimiter() == Delimiter::Parenthesis =>
46                        {
47                            group
48                        }
49                        Some(wrong) => return Err(Error::new(wrong.span(), "expected `(`")),
50                        None => {
51                            return Err(Error::new2(
52                                ident.span(),
53                                bang.span(),
54                                "expected `(` after `env!`",
55                            ));
56                        }
57                    };
58                    let mut inner = parenthesized.stream().into_iter();
59                    let lit = match inner.next() {
60                        Some(TokenTree::Literal(lit)) => lit,
61                        Some(wrong) => {
62                            return Err(Error::new(wrong.span(), "expected string literal"))
63                        }
64                        None => {
65                            return Err(Error::new2(
66                                ident.span(),
67                                parenthesized.span(),
68                                "expected string literal as argument to env! macro",
69                            ))
70                        }
71                    };
72
73                    segments.push(Segment::Env(LitStr {
74                        value: get_literal_string_value(&lit, false, false)?,
75                        span: lit.span(),
76                    }));
77
78                    if let Some(unexpected) = inner.next() {
79                        return Err(Error::new(
80                            unexpected.span(),
81                            "unexpected token in env! macro",
82                        ));
83                    }
84                } else {
85                    segments.push(Segment::String(LitStr {
86                        value: fragment,
87                        span: ident.span(),
88                    }));
89                }
90            }
91            TokenTree::Literal(lit) => {
92                segments.push(Segment::String(LitStr {
93                    value: lit.to_string(),
94                    span: lit.span(),
95                }));
96            }
97            // Note: `_` is always tokenized as an Ident, never a Punct, so there
98            // is no `'_'` arm here, it would be unreachable dead code.
99            TokenTree::Punct(punct) => match punct.as_char() {
100                '\'' => segments.push(Segment::Apostrophe(punct.span())),
101                ':' => {
102                    let colon_span = punct.span();
103                    let colon = Colon { span: colon_span };
104                    let ident = match tokens.next() {
105                        Some(TokenTree::Ident(ident)) => ident,
106                        wrong => {
107                            let span = wrong.as_ref().map_or(colon_span, TokenTree::span);
108                            return Err(Error::new(span, "expected identifier after `:`"));
109                        }
110                    };
111
112                    if ident.to_string().as_str() == "replace" {
113                        let replace = tokens.next();
114
115                        match replace {
116                            Some(TokenTree::Group(group))
117                                if group.delimiter() == Delimiter::Parenthesis =>
118                            {
119                                segments.push(Segment::Replace(colon, group));
120                            }
121                            _ => {
122                                return Err(Error::new2(
123                                    colon.span,
124                                    ident.span(),
125                                    "expected `(` after replace modifier",
126                                ));
127                            }
128                        }
129                    } else {
130                        segments.push(Segment::Modifier(colon, ident));
131                    }
132                }
133                '#' => segments.push(Segment::String(LitStr {
134                    value: "#".to_string(),
135                    span: punct.span(),
136                })),
137                _ => return Err(Error::new(punct.span(), "unexpected punct")),
138            },
139            TokenTree::Group(group) => {
140                if group.delimiter() == Delimiter::None {
141                    let mut inner = group.stream().into_iter().peekable();
142                    let nested = parse(&mut inner)?;
143                    if let Some(unexpected) = inner.next() {
144                        return Err(Error::new(unexpected.span(), "unexpected token"));
145                    }
146                    segments.extend(nested);
147                } else {
148                    return Err(Error::new(group.span(), "unexpected token"));
149                }
150            }
151        }
152    }
153    Ok(segments)
154}
155
156pub(crate) fn paste(segments: &[Segment]) -> Result<String> {
157    let mut evaluated = Vec::new();
158    let mut is_lifetime = false;
159
160    for (i, segment) in segments.iter().enumerate() {
161        match segment {
162            Segment::String(segment) => {
163                if segment.value.as_str() == "#" {
164                    if i == 0 {
165                        // Enable Raw mode
166                        evaluated.push(String::from("r#"));
167                        continue;
168                    }
169                    return Err(Error::new(
170                        segment.span,
171                        "`#` is reserved keyword and it enables the raw mode \
172                            (i.e. generate Raw Identifiers) and it is only allowed in \
173                            the beginning like `[< # ... >]`",
174                    ));
175                }
176                evaluated.push(segment.value.clone());
177            }
178            Segment::Apostrophe(span) => {
179                if is_lifetime {
180                    return Err(Error::new(*span, "unexpected lifetime"));
181                }
182                is_lifetime = true;
183            }
184            Segment::Env(var) => {
185                let resolved = match std::env::var(&var.value) {
186                    Ok(resolved) => resolved,
187                    Err(_) => {
188                        return Err(Error::new(
189                            var.span,
190                            &format!("no such env var: {:?}", var.value),
191                        ));
192                    }
193                };
194                let resolved = resolved.replace('-', "_");
195                evaluated.push(resolved);
196            }
197            Segment::Modifier(colon, ident) => {
198                let last = match evaluated.pop() {
199                    Some(last) => last,
200                    None => {
201                        return Err(Error::new2(colon.span, ident.span(), "unexpected modifier"))
202                    }
203                };
204                match ident.to_string().as_str() {
205                    "lower" => {
206                        evaluated.push(last.to_lowercase());
207                    }
208                    "upper" => {
209                        evaluated.push(last.to_uppercase());
210                    }
211                    "snake" => {
212                        let mut acc = String::new();
213                        let mut prev = '_';
214                        for ch in last.chars() {
215                            if ch.is_uppercase() && prev != '_' {
216                                acc.push('_');
217                            }
218                            acc.push(ch);
219                            prev = ch;
220                        }
221                        evaluated.push(acc.to_lowercase());
222                    }
223                    "camel" | "upper_camel" | "lower_camel" => {
224                        let mut is_lower_camel = ident.to_string().as_str() == "lower_camel";
225                        let mut acc = String::new();
226                        let mut prev = '_';
227                        for ch in last.chars() {
228                            if ch != '_' {
229                                if prev == '_' {
230                                    if is_lower_camel {
231                                        for chl in ch.to_lowercase() {
232                                            acc.push(chl);
233                                        }
234                                        is_lower_camel = false;
235                                    } else {
236                                        for chu in ch.to_uppercase() {
237                                            acc.push(chu);
238                                        }
239                                    }
240                                } else if prev.is_uppercase() {
241                                    for chl in ch.to_lowercase() {
242                                        acc.push(chl);
243                                    }
244                                } else {
245                                    acc.push(ch);
246                                }
247                            }
248                            prev = ch;
249                        }
250                        evaluated.push(acc);
251                    }
252                    "camel_edge" => {
253                        let mut acc = String::new();
254                        let mut prev = '_';
255                        for ch in last.chars() {
256                            if ch != '_' {
257                                if prev == '_' {
258                                    for chu in ch.to_uppercase() {
259                                        acc.push(chu);
260                                    }
261                                } else if prev.is_uppercase() {
262                                    for chl in ch.to_lowercase() {
263                                        acc.push(chl);
264                                    }
265                                } else {
266                                    acc.push(ch);
267                                }
268                            } else if prev == '_' {
269                                acc.push(ch);
270                            }
271                            prev = ch;
272                        }
273                        evaluated.push(acc);
274                    }
275                    _ => {
276                        return Err(Error::new2(
277                            colon.span,
278                            ident.span(),
279                            "unsupported modifier",
280                        ));
281                    }
282                }
283            }
284            Segment::Replace(colon, group) => {
285                let mut inner_stream = group.stream().into_iter();
286                let from = inner_stream.next();
287                let punct = inner_stream.next();
288                let to = inner_stream.next();
289
290                if let Some(unexpected_token) = inner_stream.next() {
291                    return Err(Error::new(unexpected_token.span(), "expected `)`"));
292                }
293
294                match (from, punct, to) {
295                    (Some(from), Some(TokenTree::Punct(punct)), Some(to))
296                        if punct.as_char() == ',' =>
297                    {
298                        let last =
299                            match evaluated.pop() {
300                                Some(last) => last,
301                                None => return Err(Error::new2(
302                                    colon.span,
303                                    group.span(),
304                                    "replace modifier requires a preceding value to operate on.",
305                                )),
306                            };
307
308                        let from_str = get_token_tree_string_value(&from)?;
309                        let to_str = get_token_tree_string_value(&to)?;
310
311                        let new_ident = last.replace(&from_str, &to_str);
312
313                        evaluated.push(new_ident);
314                    }
315                    _ => {
316                        return Err(Error::new(
317                            group.span(),
318                            "expected replace modifier format: `:replace(\"from\", \"to\")`",
319                        ))
320                    }
321                }
322            }
323        }
324    }
325
326    let mut pasted = evaluated.into_iter().collect::<String>();
327    if is_lifetime {
328        pasted.insert(0, '\'');
329    }
330    Ok(pasted)
331}
332
333// The three defensive sub-conditions below can never evaluate to false when called
334// from get_literal_string_value with a real proc_macro::Literal, because-
335//
336//   ends_with('"')   — the Rust tokenizer rejects unterminated string literals before
337//                      the macro receives them, so starts_with('"') implies ends_with('"').
338//   ends_with('\'')  — same: the tokenizer rejects unterminated char literals.
339//   len() >= 2       — impossible once both prefix and suffix chars are confirmed present.
340//
341// These checks are kept for correctness in case this function is called with an
342// arbitrary &str in the future.  The false branches are exercised by the
343// unit tests below, which call is_quoted_string_or_char directly
344// with raw &str values (e.g. "\"abc", "'abc", "\"").
345// proc_macro::Literal has no constructor that produces such malformed tokens, so
346// the test_helpers.rs (with paste_test macro) path cannot cover these branches.
347fn is_quoted_string_or_char(l_str: &str, parse_char: bool) -> bool {
348    ((l_str.starts_with('"') && l_str.ends_with('"'))
349        || (parse_char && l_str.starts_with('\'') && l_str.ends_with('\'')))
350        && l_str.len() >= 2
351}
352
353fn get_literal_string_value(l: &Literal, parse_char: bool, parse_numbers: bool) -> Result<String> {
354    let l_str = l.to_string();
355
356    if is_quoted_string_or_char(&l_str, parse_char) {
357        // TODO: maybe handle escape sequences in the string if
358        // someone has a use case.
359        Ok(String::from(&l_str[1..l_str.len() - 1]))
360    } else if parse_numbers {
361        Ok(l_str)
362    } else {
363        Err(Error::new(l.span(), "expected string literal"))
364    }
365}
366
367pub(crate) fn get_token_tree_string_value(t: &TokenTree) -> Result<String> {
368    match t {
369        TokenTree::Ident(ident) => Ok(ident.to_string()),
370        TokenTree::Literal(literal) => get_literal_string_value(literal, true, true),
371        TokenTree::Group(group) if group.delimiter() == Delimiter::None => {
372            // Handle interpolated tokens from macro_rules (common in older Rust versions)
373            let mut inner = group.stream().into_iter();
374            if let Some(first) = inner.next() {
375                if inner.next().is_none() {
376                    // Single token in the group, recursively process it
377                    return get_token_tree_string_value(&first);
378                }
379            }
380            Err(Error::new(t.span(), "Expected either Ident, or Literal."))
381        }
382        _ => Err(Error::new(t.span(), "Expected either Ident, or Literal.")),
383    }
384}
385
386#[cfg(test)]
387mod tests {
388    use super::is_quoted_string_or_char;
389
390    #[test]
391    fn test_is_quoted_string_or_char() {
392        assert!(is_quoted_string_or_char("\"hello\"", false));
393        assert!(!is_quoted_string_or_char("abc", false));
394        assert!(!is_quoted_string_or_char("\"", false));
395        assert!(!is_quoted_string_or_char("\"abc", false));
396        assert!(is_quoted_string_or_char("'a'", true));
397        assert!(!is_quoted_string_or_char("'abc", true));
398        assert!(!is_quoted_string_or_char("abc", true));
399    }
400}
401
402#[cfg(doctest)]
403#[doc(hidden)]
404mod doc_tests {
405    /// ```compile_fail
406    /// use pastey::paste;
407    /// paste! { fn [<a + b>]() {} }
408    /// ```
409    fn test_unexpected_punct() {}
410
411    /// ```compile_fail
412    /// use pastey::paste;
413    /// paste! { fn [<{}>]() {} }
414    /// ```
415    fn test_unexpected_group() {}
416
417    /// ```compile_fail
418    /// use pastey::paste;
419    /// paste! { fn [<env! foo>]() {} }
420    /// ```
421    fn test_env_missing_paren() {}
422
423    /// ```compile_fail
424    /// use pastey::paste;
425    /// paste! { fn [<env!(foo)>]() {} }
426    /// ```
427    fn test_env_non_literal_arg() {}
428
429    /// ```compile_fail
430    /// use pastey::paste;
431    /// paste! { fn [<env!()>]() {} }
432    /// ```
433    fn test_env_empty() {}
434
435    /// ```compile_fail
436    /// use pastey::paste;
437    /// paste! { fn [<env!("CARGO_PKG_NAME" "extra")>]() {} }
438    /// ```
439    fn test_env_unexpected_token() {}
440
441    /// ```compile_fail
442    /// use pastey::paste;
443    /// paste! { fn [<a:>]() {} }
444    /// ```
445    fn test_no_ident_after_colon() {}
446
447    /// ```compile_fail
448    /// use pastey::paste;
449    /// paste! { fn [<a:replace x>]() {} }
450    /// ```
451    fn test_replace_missing_paren() {}
452
453    /// ```compile_fail
454    /// use pastey::paste;
455    /// paste! { fn [<a:pillow>]() {} }
456    /// ```
457    fn test_unsupported_modifier() {}
458
459    /// ```compile_fail
460    /// use pastey::paste;
461    /// paste! { fn [<a:replace("x","y","z")>]() {} }
462    /// ```
463    fn test_replace_extra_token() {}
464
465    /// ```compile_fail
466    /// use pastey::paste;
467    /// paste! { struct [<:replace("H","W")>]; }
468    /// ```
469    fn test_replace_no_preceding_value() {}
470
471    /// ```compile_fail
472    /// use pastey::paste;
473    /// paste! { fn [<a:replace(x)>]() {} }
474    /// ```
475    fn test_replace_wrong_format() {}
476
477    /// ```compile_fail
478    /// use pastey::paste;
479    /// paste! { struct [<foo # bar>]; }
480    /// ```
481    fn test_raw_mode_wrong_position() {}
482
483    /// ```compile_fail
484    /// use pastey::paste;
485    /// paste! { fn [<'a 'b>]() {} }
486    /// ```
487    fn test_unexpected_lifetime() {}
488
489    /// ```compile_fail
490    /// use pastey::paste;
491    /// paste! { fn [<env!("THIS_VAR_DOES_NOT_EXIST_XYZ_999")>]() {} }
492    /// ```
493    fn test_no_such_env_var() {}
494
495    /// ```compile_fail
496    /// use pastey::paste;
497    /// paste! { fn [<:lower>]() {} }
498    /// ```
499    fn test_modifier_no_preceding_value() {}
500
501    /// ```compile_fail
502    /// use pastey::paste;
503    /// paste! { fn [<env!["CARGO_PKG_NAME"]>]() {} }
504    /// ```
505    fn test_env_bracket_group() {}
506
507    /// ```compile_fail
508    /// use pastey::paste;
509    /// paste! { struct [<a:replace["x", "y"]>]; }
510    /// ```
511    fn test_replace_bracket_group() {}
512
513    /// ```compile_fail
514    /// use pastey::paste;
515    /// macro_rules! m {
516    ///     ($e:expr) => { paste! { fn [<$e foo>]() {} } }
517    /// }
518    /// m!(1 > 0);
519    /// ```
520    fn test_none_group_unexpected_token() {}
521
522    /// ```compile_fail
523    /// use pastey::paste;
524    /// paste! { struct [<a:replace("x"; "y")>]; }
525    /// ```
526    fn test_replace_wrong_separator() {}
527
528    /// ```compile_fail
529    /// use pastey::paste;
530    /// paste! { fn [<env!(42)>]() {} }
531    /// ```
532    fn test_env_numeric_literal() {}
533
534    /// ```compile_fail
535    /// use pastey::paste;
536    /// paste! { fn [<env!('a')>]() {} }
537    /// ```
538    fn test_env_char_literal() {}
539
540    /// ```compile_fail
541    /// use pastey::paste;
542    /// paste! { struct [<Foo:replace(["x"], "y")>]; }
543    /// ```
544    fn test_replace_from_bracket_group() {}
545
546    /// ```compile_fail
547    /// use pastey::paste;
548    /// macro_rules! m {
549    ///     ($from:expr) => { paste! { struct [<Foo:replace($from, "y")>]; } }
550    /// }
551    /// m!(x + y);
552    /// ```
553    fn test_replace_from_multi_token_none_group() {}
554
555    /// ```compile_fail
556    /// use pastey::paste;
557    /// macro_rules! m {
558    ///     ($to:expr) => { paste! { struct [<Foo:replace("o", $to)>]; } }
559    /// }
560    /// m!(x + y);
561    /// ```
562    fn test_replace_to_multi_token_none_group() {}
563}