rust: macros: paste: add support for using var as part of group

The following code is currently working fine and will generate a struct
named "Test0":

	kernel::macros::paste! {
	    struct [<Test 0>];
	}

But if we need to use a "macro variable" like this:

	macro_rules! test {
	    ($i: literal) => {
		kernel::macros::paste! {
		    struct [<Test $i>];
		}
	    };
	}

	test!(0);

The code above will make the paste! macro panic:

	error: proc macro panicked
	  --> drivers/regulator/ncv6336.rs:25:9
	   |
	25 | /         kernel::macros::paste! {
	26 | |             struct [<Test $i>];
	27 | |         }
	   | |_________^
	...
	31 |   test!(0);
	   |   -------- in this macro invocation
	   |
	   = help: message: unexpected token in paste segments

The reason of this panic is that "macro variables" are creating
`Groups` [0], with the `None` delimiter [1], and currently `Groups`are not
handled by the paste! macro.

This commit adds support for TokenTree::Group token where the delimiter
is None in order to make the previous code snippet now work.

[0] https://doc.rust-lang.org/proc_macro/struct.Group.html
[1] https://doc.rust-lang.org/proc_macro/enum.Delimiter.html#variant.None

Signed-off-by: Fabien Parent <fabien.parent@linaro.org>

Author: Fabo

rust/macros/paste.rs

@@ -2,7 +2,7 @@
 
 use proc_macro::{Delimiter, Group, Ident, Spacing, Span, TokenTree};
 
-fn concat(tokens: &[TokenTree], group_span: Span) -> TokenTree {
+fn process_tokens_into_segments(tokens: &[TokenTree]) -> (Vec<(String, Span)>, Option<Span>) {
     let mut tokens = tokens.iter();
     let mut segments = Vec::new();
     let mut span = None;
@@ -46,10 +46,29 @@ fn concat(tokens: &[TokenTree], group_span: Span) -> TokenTree {
                 };
                 segments.push((value, sp));
             }
+            Some(TokenTree::Group(group)) if group.delimiter() == Delimiter::None => {
+                let group_tokens: Vec<_> = group.stream().into_iter().collect();
+                let (group_segments, group_span) = process_tokens_into_segments(&group_tokens);
+                segments.extend(group_segments);
+
+                assert!(
+                    !(span.is_some() && group_span.is_some()),
+                    "span modifier should only appear at most once"
+                );
+
+                if group_span.is_some() {
+                    span = group_span;
+                }
+            }
             _ => panic!("unexpected token in paste segments"),
         };
     }
 
+    (segments, span)
+}
+
+fn concat(tokens: &[TokenTree], group_span: Span) -> TokenTree {
+    let (segments, span) = process_tokens_into_segments(tokens);
     let pasted: String = segments.into_iter().map(|x| x.0).collect();
     TokenTree::Ident(Ident::new(&pasted, span.unwrap_or(group_span)))
 }