channels-macros 0.1.0

Procedural macros for channels.
Documentation 
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use core::iter::Peekable;

use proc_macro::{Delimiter, Group, Ident, Punct, TokenTree};

/// Try to parse an identifier from `stream`.
///
/// This function will return [`None`] without advancing `stream` if an identifier
/// is not the next token of `stream`. Otherwise it will advance `stream` and
/// return the [`Ident`].
pub fn try_parse_ident<I>(stream: &mut Peekable<I>) -> Option<Ident>
where
	I: Iterator<Item = TokenTree>,
{
	use TokenTree as TT;

	match stream.peek()? {
		TT::Ident(_) => {
			let TT::Ident(x) = stream
				.next()
				.expect("next() should have returned Some")
			else {
				panic!("peek() did not return the next element")
			};

			Some(x)
		},
		_ => None,
	}
}

/// Try to parse a punctuation from `stream`.
///
/// This function will return [`None`] without advancing `stream` if a punctuation
/// is not the next token of `stream`. Otherwise it will advance `stream` and
/// return the [`Punct`].
pub fn try_parse_punct<I>(stream: &mut Peekable<I>) -> Option<Punct>
where
	I: Iterator<Item = TokenTree>,
{
	use TokenTree as TT;

	let next = stream.peek()?;

	match next {
		TT::Punct(_) => {
			let TT::Punct(x) = stream
				.next()
				.expect("next() should have returned Some")
			else {
				panic!("peek() did not return the next element")
			};

			Some(x)
		},

		_ => None,
	}
}

/// Try to parse a group from `stream`.
///
/// This function will return [`None`] without advancing `stream` if a group
/// is not the next token of `stream`. Otherwise it will advance `stream` and
/// return the [`Group`].
pub fn try_parse_group<I>(stream: &mut Peekable<I>) -> Option<Group>
where
	I: Iterator<Item = TokenTree>,
{
	use TokenTree as TT;

	let next = stream.peek()?;

	match next {
		TT::Group(_) => {
			let TT::Group(x) = stream
				.next()
				.expect("next() should have returned Some")
			else {
				panic!("peek() did not return the next element")
			};

			Some(x)
		},
		_ => None,
	}
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum TryParseError {
	NotFound,
	NotExpected,
}

/// Try to parse an identifier from `stream` and fail if it is not `expected`.
pub fn try_parse_ident_expected<I>(
	stream: &mut Peekable<I>,
	expected: &str,
) -> Result<Ident, TryParseError>
where
	I: Iterator<Item = TokenTree>,
{
	let ident =
		try_parse_ident(stream).ok_or(TryParseError::NotFound)?;

	if ident.to_string() == expected {
		Ok(ident)
	} else {
		Err(TryParseError::NotExpected)
	}
}

/// Try to parse a punctuation from `stream` and fail if it is not `expected`.
pub fn try_parse_punct_expected<I>(
	stream: &mut Peekable<I>,
	expected: char,
) -> Result<Punct, TryParseError>
where
	I: Iterator<Item = TokenTree>,
{
	let punct =
		try_parse_punct(stream).ok_or(TryParseError::NotFound)?;

	if punct.as_char() == expected {
		Ok(punct)
	} else {
		Err(TryParseError::NotExpected)
	}
}

/// Try to parse a group from `stream` and fail if it is not `expected`.
pub fn try_parse_group_expected<I>(
	stream: &mut Peekable<I>,
	delimiter: Delimiter,
) -> Result<Group, TryParseError>
where
	I: Iterator<Item = TokenTree>,
{
	let group =
		try_parse_group(stream).ok_or(TryParseError::NotFound)?;

	if group.delimiter() == delimiter {
		Ok(group)
	} else {
		Err(TryParseError::NotExpected)
	}
}