Skip to content

Commit cee6852

Browse files
DoumanAshDoumanAsh
committed
Upgrade to combine 4.x.y
1 parent 8a759df commit cee6852

File tree

6 files changed

+146
-208
lines changed

6 files changed

+146
-208
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 {
@@ -78,9 +77,8 @@ impl From<i32> for Number {
7877
}
7978
}
8079

81-
pub fn directives<'a, T>(input: &mut TokenStream<'a>)
82-
-> ParseResult<Vec<Directive<'a, T>>, TokenStream<'a>>
83-
where T: Text<'a>,
80+
pub fn directives<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Vec<Directive<'a, T>>, TokenStream<'a>>
81+
where T: Text<'a>,
8482
{
8583
many(position()
8684
.skip(punct("@"))
@@ -89,11 +87,10 @@ pub fn directives<'a, T>(input: &mut TokenStream<'a>)
8987
.map(|((position, name), arguments)| {
9088
Directive { position, name, arguments }
9189
}))
92-
.parse_stream(input)
90+
.parse_stream(input).into()
9391
}
9492

95-
pub fn arguments<'a, T>(input: &mut TokenStream<'a>)
96-
-> ParseResult<Vec<(T::Value, Value<'a, T>)>, TokenStream<'a>>
93+
pub fn arguments<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Vec<(T::Value, Value<'a, T>)>, TokenStream<'a>>
9794
where T: Text<'a>,
9895
{
9996
optional(
@@ -105,25 +102,23 @@ pub fn arguments<'a, T>(input: &mut TokenStream<'a>)
105102
.map(|opt| {
106103
opt.unwrap_or_else(Vec::new)
107104
})
108-
.parse_stream(input)
105+
.parse_stream(input).into()
109106
}
110107

111-
pub fn int_value<'a, S>(input: &mut TokenStream<'a>)
112-
-> ParseResult<Value<'a, S>, TokenStream<'a>>
108+
pub fn int_value<'a, S>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, S>, TokenStream<'a>>
113109
where S: Text<'a>
114110
{
115111
kind(T::IntValue).and_then(|tok| tok.value.parse())
116112
.map(Number).map(Value::Int)
117-
.parse_stream(input)
113+
.parse_stream(input).into()
118114
}
119115

120-
pub fn float_value<'a, S>(input: &mut TokenStream<'a>)
121-
-> ParseResult<Value<'a, S>, TokenStream<'a>>
116+
pub fn float_value<'a, S>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, S>, TokenStream<'a>>
122117
where S: Text<'a>
123118
{
124119
kind(T::FloatValue).and_then(|tok| tok.value.parse())
125120
.map(Value::Float)
126-
.parse_stream(input)
121+
.parse_stream(input).into()
127122
}
128123

129124
fn unquote_block_string<'a>(src: &'a str) -> Result<String, Error<Token<'a>, Token<'a>>> {
@@ -162,7 +157,7 @@ fn unquote_block_string<'a>(src: &'a str) -> Result<String, Error<Token<'a>, Tok
162157
Ok(result)
163158
}
164159

165-
fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
160+
fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
166161
{
167162
let mut res = String::with_capacity(s.len());
168163
debug_assert!(s.starts_with('"') && s.ends_with('"'));
@@ -183,7 +178,7 @@ fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
183178
for _ in 0..4 {
184179
match chars.next() {
185180
Some(inner_c) => temp_code_point.push(inner_c),
186-
None => return Err(Error::unexpected_message(
181+
None => return Err(Error::unexpected_format(
187182
format_args!("\\u must have 4 characters after it, only found '{}'", temp_code_point)
188183
)),
189184
}
@@ -193,13 +188,13 @@ fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
193188
match u32::from_str_radix(&temp_code_point, 16).map(std::char::from_u32) {
194189
Ok(Some(unicode_char)) => res.push(unicode_char),
195190
_ => {
196-
return Err(Error::unexpected_message(
191+
return Err(Error::unexpected_format(
197192
format_args!("{} is not a valid unicode code point", temp_code_point)))
198193
}
199194
}
200195
},
201196
c => {
202-
return Err(Error::unexpected_message(
197+
return Err(Error::unexpected_format(
203198
format_args!("bad escaped char {:?}", c)));
204199
}
205200
}
@@ -211,35 +206,31 @@ fn unquote_string<'a>(s: &'a str) -> Result<String, Error<Token, Token>>
211206
Ok(res)
212207
}
213208

214-
pub fn string<'a>(input: &mut TokenStream<'a>)
215-
-> ParseResult<String, TokenStream<'a>>
209+
pub fn string<'a>(input: &mut TokenStream<'a>) -> StdParseResult<String, TokenStream<'a>>
216210
{
217211
choice((
218212
kind(T::StringValue).and_then(|tok| unquote_string(tok.value)),
219213
kind(T::BlockString).and_then(|tok| unquote_block_string(tok.value)),
220-
)).parse_stream(input)
214+
)).parse_stream(input).into()
221215
}
222216

223-
pub fn string_value<'a, S>(input: &mut TokenStream<'a>)
224-
-> ParseResult<Value<'a, S>, TokenStream<'a>>
217+
pub fn string_value<'a, S>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, S>, TokenStream<'a>>
225218
where S: Text<'a>,
226219
{
227220
kind(T::StringValue).and_then(|tok| unquote_string(tok.value))
228221
.map(Value::String)
229-
.parse_stream(input)
222+
.parse_stream(input).into()
230223
}
231224

232-
pub fn block_string_value<'a, S>(input: &mut TokenStream<'a>)
233-
-> ParseResult<Value<'a, S>, TokenStream<'a>>
225+
pub fn block_string_value<'a, S>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, S>, TokenStream<'a>>
234226
where S: Text<'a>,
235227
{
236228
kind(T::BlockString).and_then(|tok| unquote_block_string(tok.value))
237229
.map(Value::String)
238-
.parse_stream(input)
230+
.parse_stream(input).into()
239231
}
240232

241-
pub fn plain_value<'a, T>(input: &mut TokenStream<'a>)
242-
-> ParseResult<Value<'a, T>, TokenStream<'a>>
233+
pub fn plain_value<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, T>, TokenStream<'a>>
243234
where T: Text<'a>,
244235
{
245236
ident("true").map(|_| Value::Boolean(true))
@@ -250,11 +241,10 @@ pub fn plain_value<'a, T>(input: &mut TokenStream<'a>)
250241
.or(parser(float_value))
251242
.or(parser(string_value))
252243
.or(parser(block_string_value))
253-
.parse_stream(input)
244+
.parse_stream(input).into()
254245
}
255246

256-
pub fn value<'a, T>(input: &mut TokenStream<'a>)
257-
-> ParseResult<Value<'a, T>, TokenStream<'a>>
247+
pub fn value<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, T>, TokenStream<'a>>
258248
where T: Text<'a>,
259249
{
260250
parser(plain_value)
@@ -265,11 +255,10 @@ pub fn value<'a, T>(input: &mut TokenStream<'a>)
265255
.with(many(name::<'a, T>().skip(punct(":")).and(parser(value))))
266256
.skip(punct("}"))
267257
.map(Value::Object))
268-
.parse_stream(input)
258+
.parse_stream(input).into()
269259
}
270260

271-
pub fn default_value<'a, T>(input: &mut TokenStream<'a>)
272-
-> ParseResult<Value<'a, T>, TokenStream<'a>>
261+
pub fn default_value<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Value<'a, T>, TokenStream<'a>>
273262
where T: Text<'a>,
274263
{
275264
parser(plain_value)
@@ -279,11 +268,10 @@ pub fn default_value<'a, T>(input: &mut TokenStream<'a>)
279268
.with(many(name::<'a, T>().skip(punct(":")).and(parser(default_value))))
280269
.skip(punct("}"))
281270
.map(Value::Object))
282-
.parse_stream(input)
271+
.parse_stream(input).into()
283272
}
284273

285-
pub fn parse_type<'a, T>(input: &mut TokenStream<'a>)
286-
-> ParseResult<Type<'a, T>, TokenStream<'a>>
274+
pub fn parse_type<'a, T>(input: &mut TokenStream<'a>) -> StdParseResult<Type<'a, T>, TokenStream<'a>>
287275
where T: Text<'a>,
288276
{
289277
name::<'a, T>().map(Type::NamedType)
@@ -300,7 +288,7 @@ pub fn parse_type<'a, T>(input: &mut TokenStream<'a>)
300288
typ
301289
}
302290
)
303-
.parse_stream(input)
291+
.parse_stream(input).into()
304292
}
305293

306294
#[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)