Skip to content

Commit f76acf5

Browse files
DoumanAshDoumanAsh
committed
Upgrade to combine 4.x.y
1 parent be86bc9 commit f76acf5

File tree

6 files changed

+143
-206
lines changed

6 files changed

+143
-206
lines changed

‎Cargo.toml

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ authors = ["Paul Colomiets <paul@colomiets.name>"]
1515
edition = "2018"
1616

1717
[dependencies]
18-
combine = "3.2.0"
18+
combine = "4.6.0"
1919
thiserror = "1.0.11"
2020

2121
[dev-dependencies]

‎src/common.rs

Lines changed: 29 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,8 @@
11
use std::{fmt, collections::BTreeMap};
22

3-
use combine::{parser, ParseResult, Parser};
3+
use combine::{parser, StdParseResult, Parser, many, many1, optional, position, choice};
44
use combine::easy::Error;
55
use combine::error::StreamError;
6-
use combine::combinator::{many, many1, optional, position, choice};
76

87
use crate::tokenizer::{Kind as T, Token, TokenStream};
98
use crate::helpers::{punct, ident, kind, name};
@@ -12,7 +11,7 @@ use crate::position::Pos;
1211
/// Text abstracts over types that hold a string value.
1312
/// It is used to make the AST generic over the string type.
1413
pub trait Text<'a>: 'a {
15-
type Value: 'a + From<&'a str> + AsRef<str> + std::borrow::Borrow<str> + PartialEq + Eq + PartialOrd + Ord + fmt::Debug + Clone;
14+
type Value: 'a + From<&'a str> + AsRef<str> + std::borrow::Borrow<str> + PartialEq + Eq + PartialOrd + Ord + fmt::Debug + Clone;
1615
}
1716

1817
impl<'a> Text<'a> for &'a str {
@@ -98,9 +97,8 @@ impl From<i32> for Number {
9897
}
9998
}
10099

101-
pub fn directives<'a, T>(input: &mut TokenStream<'a>)
102-
-> ParseResult<Vec<Directive<'a, T>>, TokenStream<'a>>
103-
where T: Text<'a>,
100+
pub fn directives<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Vec<Directive<'a, T>>, TokenStream<'a>>
101+
where T: Text<'a>,
104102
{
105103
many(position()
106104
.skip(punct("@"))
@@ -109,11 +107,10 @@ pub fn directives<'a, T>(input: &mut TokenStream<'a>)
109107
.map(|((position, name), arguments)| {
110108
Directive { position, name, arguments }
111109
}))
112-
.parse_stream(input)
110+
.parse_stream(input).into()
113111
}
114112

115-
pub fn arguments<'a, T>(input: &mut TokenStream<'a>)
116-
-> ParseResult<Vec<(T::Value, Value<'a, T>)>, TokenStream<'a>>
113+
pub fn arguments<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Vec<(T::Value, Value<'a, T>)>, TokenStream<'a>>
117114
where T: Text<'a>,
118115
{
119116
optional(
@@ -125,25 +122,23 @@ pub fn arguments<'a, T>(input: &mut TokenStream<'a>)
125122
.map(|opt| {
126123
opt.unwrap_or_else(Vec::new)
127124
})
128-
.parse_stream(input)
125+
.parse_stream(input).into()
129126
}
130127

131-
pub fn int_value<'a, S>(input: &mut TokenStream<'a>)
132-
-> ParseResult<Value<'a, S>, TokenStream<'a>>
128+
pub fn int_value<'a, S>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, S>, TokenStream<'a>>
133129
where S: Text<'a>
134130
{
135131
kind(T::IntValue).and_then(|tok| tok.value.parse())
136132
.map(Number).map(Value::Int)
137-
.parse_stream(input)
133+
.parse_stream(input).into()
138134
}
139135

140-
pub fn float_value<'a, S>(input: &mut TokenStream<'a>)
141-
-> ParseResult<Value<'a, S>, TokenStream<'a>>
136+
pub fn float_value<'a, S>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, S>, TokenStream<'a>>
142137
where S: Text<'a>
143138
{
144139
kind(T::FloatValue).and_then(|tok| tok.value.parse())
145140
.map(Value::Float)
146-
.parse_stream(input)
141+
.parse_stream(input).into()
147142
}
148143

149144
fn unquote_block_string<'a>(src: &'a str) -> Result<String, Error<Token<'a>, Token<'a>>> {
@@ -182,7 +177,7 @@ fn unquote_block_string<'a>(src: &'a str) -> Result<String, Error<Token<'a>, Tok
182177
Ok(result)
183178
}
184179

185-
fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
180+
fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
186181
{
187182
let mut res = String::with_capacity(s.len());
188183
debug_assert!(s.starts_with('"') && s.ends_with('"'));
@@ -203,7 +198,7 @@ fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
203198
for _ in 0..4 {
204199
match chars.next() {
205200
Some(inner_c) => temp_code_point.push(inner_c),
206-
None => return Err(Error::unexpected_message(
201+
None => return Err(Error::unexpected_format(
207202
format_args!("\\u must have 4 characters after it, only found '{}'", temp_code_point)
208203
)),
209204
}
@@ -213,13 +208,13 @@ fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
213208
match u32::from_str_radix(&temp_code_point, 16).map(std::char::from_u32) {
214209
Ok(Some(unicode_char)) => res.push(unicode_char),
215210
_ => {
216-
return Err(Error::unexpected_message(
211+
return Err(Error::unexpected_format(
217212
format_args!("{} is not a valid unicode code point", temp_code_point)))
218213
}
219214
}
220215
},
221216
c => {
222-
return Err(Error::unexpected_message(
217+
return Err(Error::unexpected_format(
223218
format_args!("bad escaped char {:?}", c)));
224219
}
225220
}
@@ -231,35 +226,31 @@ fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
231226
Ok(res)
232227
}
233228

234-
pub fn string<'a>(input: &mut TokenStream<'a>)
235-
-> ParseResult<String, TokenStream<'a>>
229+
pub fn string<'a>(input: &mut TokenStream<'a>) -> StdParseResult<String, TokenStream<'a>>
236230
{
237231
choice((
238232
kind(T::StringValue).and_then(|tok| unquote_string(tok.value)),
239233
kind(T::BlockString).and_then(|tok| unquote_block_string(tok.value)),
240-
)).parse_stream(input)
234+
)).parse_stream(input).into()
241235
}
242236

243-
pub fn string_value<'a, S>(input: &mut TokenStream<'a>)
244-
-> ParseResult<Value<'a, S>, TokenStream<'a>>
237+
pub fn string_value<'a, S>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, S>, TokenStream<'a>>
245238
where S: Text<'a>,
246239
{
247240
kind(T::StringValue).and_then(|tok| unquote_string(tok.value))
248241
.map(Value::String)
249-
.parse_stream(input)
242+
.parse_stream(input).into()
250243
}
251244

252-
pub fn block_string_value<'a, S>(input: &mut TokenStream<'a>)
253-
-> ParseResult<Value<'a, S>, TokenStream<'a>>
245+
pub fn block_string_value<'a, S>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, S>, TokenStream<'a>>
254246
where S: Text<'a>,
255247
{
256248
kind(T::BlockString).and_then(|tok| unquote_block_string(tok.value))
257249
.map(Value::String)
258-
.parse_stream(input)
250+
.parse_stream(input).into()
259251
}
260252

261-
pub fn plain_value<'a, T>(input: &mut TokenStream<'a>)
262-
-> ParseResult<Value<'a, T>, TokenStream<'a>>
253+
pub fn plain_value<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, T>, TokenStream<'a>>
263254
where T: Text<'a>,
264255
{
265256
ident("true").map(|_| Value::Boolean(true))
@@ -270,11 +261,10 @@ pub fn plain_value<'a, T>(input: &mut TokenStream<'a>)
270261
.or(parser(float_value))
271262
.or(parser(string_value))
272263
.or(parser(block_string_value))
273-
.parse_stream(input)
264+
.parse_stream(input).into()
274265
}
275266

276-
pub fn value<'a, T>(input: &mut TokenStream<'a>)
277-
-> ParseResult<Value<'a, T>, TokenStream<'a>>
267+
pub fn value<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, T>, TokenStream<'a>>
278268
where T: Text<'a>,
279269
{
280270
parser(plain_value)
@@ -285,11 +275,10 @@ pub fn value<'a, T>(input: &mut TokenStream<'a>)
285275
.with(many(name::<'a, T>().skip(punct(":")).and(parser(value))))
286276
.skip(punct("}"))
287277
.map(Value::Object))
288-
.parse_stream(input)
278+
.parse_stream(input).into()
289279
}
290280

291-
pub fn default_value<'a, T>(input: &mut TokenStream<'a>)
292-
-> ParseResult<Value<'a, T>, TokenStream<'a>>
281+
pub fn default_value<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, T>, TokenStream<'a>>
293282
where T: Text<'a>,
294283
{
295284
parser(plain_value)
@@ -299,11 +288,10 @@ pub fn default_value<'a, T>(input: &mut TokenStream<'a>)
299288
.with(many(name::<'a, T>().skip(punct(":")).and(parser(default_value))))
300289
.skip(punct("}"))
301290
.map(Value::Object))
302-
.parse_stream(input)
291+
.parse_stream(input).into()
303292
}
304293

305-
pub fn parse_type<'a, T>(input: &mut TokenStream<'a>)
306-
-> ParseResult<Type<'a, T>, TokenStream<'a>>
294+
pub fn parse_type<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Type<'a, T>, TokenStream<'a>>
307295
where T: Text<'a>,
308296
{
309297
name::<'a, T>().map(Type::NamedType)
@@ -320,7 +308,7 @@ pub fn parse_type<'a, T>(input: &mut TokenStream<'a>)
320308
typ
321309
}
322310
)
323-
.parse_stream(input)
311+
.parse_stream(input).into()
324312
}
325313

326314
#[cfg(test)]

‎src/helpers.rs

Lines changed: 13 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
use std::marker::PhantomData;
22

3-
use combine::{Parser, ConsumedResult, satisfy, StreamOnce};
3+
use combine::{Parser, ParseResult, satisfy, StreamOnce};
44
use combine::error::{Tracked};
55
use combine::stream::easy::{Error, Errors, Info};
66

@@ -17,7 +17,7 @@ pub struct TokenMatch<'a> {
1717
}
1818

1919
#[derive(Debug, Clone)]
20-
pub struct NameMatch<'a, T>
20+
pub struct NameMatch<'a, T>
2121
where T: Text<'a>
2222
{
2323
phantom: PhantomData<&'a T>,
@@ -38,29 +38,24 @@ pub fn kind<'x>(kind: Kind) -> TokenMatch<'x> {
3838
}
3939
}
4040

41-
pub fn name<'a, T>() -> NameMatch<'a, T>
41+
pub fn name<'a, T>() -> NameMatch<'a, T>
4242
where T: Text<'a>
4343
{
4444
NameMatch {
4545
phantom: PhantomData,
4646
}
4747
}
4848

49-
impl<'a> Parser for TokenMatch<'a> {
50-
type Input = TokenStream<'a>;
49+
impl<'a> Parser<TokenStream<'a>> for TokenMatch<'a> {
5150
type Output = Token<'a>;
5251
type PartialState = ();
5352

5453
#[inline]
55-
fn parse_lazy(&mut self, input: &mut Self::Input)
56-
-> ConsumedResult<Self::Output, Self::Input>
57-
{
54+
fn parse_lazy(&mut self, input: &mut TokenStream<'a>) -> ParseResult<Self::Output, <TokenStream<'a> as StreamOnce>::Error> {
5855
satisfy(|c: Token<'a>| c.kind == self.kind).parse_lazy(input)
5956
}
6057

61-
fn add_error(&mut self,
62-
error: &mut Tracked<Errors<Token<'a>, Token<'a>, Pos>>)
63-
{
58+
fn add_error(&mut self, error: &mut Tracked<Errors<Token<'a>, Token<'a>, Pos>>) {
6459
error.error.add_error(Error::Expected(Info::Owned(
6560
format!("{:?}", self.kind))));
6661
}
@@ -82,38 +77,32 @@ pub fn ident<'s>(value: &'static str) -> Value<'s> {
8277
}
8378
}
8479

85-
impl<'a> Parser for Value<'a> {
86-
type Input = TokenStream<'a>;
80+
impl<'a> Parser<TokenStream<'a>> for Value<'a> {
8781
type Output = Token<'a>;
8882
type PartialState = ();
8983

9084
#[inline]
91-
fn parse_lazy(&mut self, input: &mut Self::Input)
92-
-> ConsumedResult<Self::Output, Self::Input>
93-
{
85+
fn parse_lazy(&mut self, input: &mut TokenStream<'a>) -> ParseResult<Self::Output, <TokenStream<'a> as StreamOnce>::Error> {
9486
satisfy(|c: Token<'a>| {
9587
c.kind == self.kind && c.value == self.value
9688
}).parse_lazy(input)
9789
}
9890

9991
fn add_error(&mut self,
100-
error: &mut Tracked<<Self::Input as StreamOnce>::Error>)
92+
error: &mut Tracked<<TokenStream<'a> as StreamOnce>::Error>)
10193
{
102-
error.error.add_error(Error::Expected(Info::Borrowed(self.value)));
94+
error.error.add_error(Error::Expected(Info::Static(self.value)));
10395
}
10496
}
10597

106-
impl<'a, S> Parser for NameMatch<'a, S>
98+
impl<'a, S> Parser<TokenStream<'a>> for NameMatch<'a, S>
10799
where S: Text<'a>,
108100
{
109-
type Input = TokenStream<'a>;
110101
type Output = S::Value;
111102
type PartialState = ();
112103

113104
#[inline]
114-
fn parse_lazy(&mut self, input: &mut Self::Input)
115-
-> ConsumedResult<Self::Output, Self::Input>
116-
{
105+
fn parse_lazy(&mut self, input: &mut TokenStream<'a>) -> ParseResult<Self::Output, <TokenStream<'a> as StreamOnce>::Error> {
117106
satisfy(|c: Token<'a>| c.kind == Kind::Name)
118107
.map(|t: Token<'a>| -> S::Value { S::Value::from(t.value) } )
119108
.parse_lazy(input)
@@ -122,6 +111,6 @@ impl<'a, S> Parser for NameMatch<'a, S>
122111
fn add_error(&mut self,
123112
error: &mut Tracked<Errors<Token<'a>, Token<'a>, Pos>>)
124113
{
125-
error.error.add_error(Error::Expected(Info::Borrowed("Name")));
114+
error.error.add_error(Error::Expected(Info::Static("Name")));
126115
}
127116
}

0 commit comments

Comments
 (0)