Skip to content

Commit 4de4170

Browse files
kornelskikornelski
committed
Use Option where possible
1 parent 068b50d commit 4de4170

File tree

3 files changed

+74
-74
lines changed

3 files changed

+74
-74
lines changed

‎src/reader/lexer.rs

Lines changed: 72 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -195,7 +195,7 @@ macro_rules! dispatch_on_enum_state(
195195
match $s {
196196
$(
197197
$st => match $c {
198-
$stc => $_self.move_to($is($next_st)),
198+
$stc => Ok($_self.move_to($is($next_st))),
199199
_ => $_self.handle_error($chunk, $c)
200200
},
201201
)+
@@ -349,7 +349,7 @@ impl Lexer {
349349
Ok(Some(Token::Character(']'))),
350350
State::InvalidCDataClosing(ClosingSubstate::Second) => {
351351
self.eof_handled = false;
352-
self.move_to_with_unread(State::Normal, &[']'], Token::Character(']'))
352+
Ok(self.move_to_with_unread(State::Normal, &[']'], Token::Character(']')))
353353
},
354354
State::Normal =>
355355
Ok(None),
@@ -368,46 +368,46 @@ impl Lexer {
368368
#[inline(never)]
369369
fn dispatch_char(&mut self, c: char) -> Result {
370370
match self.st {
371-
State::Normal => self.normal(c),
371+
State::Normal => Ok(self.normal(c)),
372372
State::TagStarted => self.tag_opened(c),
373-
State::EmptyTagClosing => self.empty_element_closing(c),
373+
State::EmptyTagClosing => Ok(self.empty_element_closing(c)),
374374
State::CommentOrCDataOrDoctypeStarted => self.comment_or_cdata_or_doctype_started(c),
375-
State::InsideCdata => self.inside_cdata(c),
375+
State::InsideCdata => Ok(self.inside_cdata(c)),
376376
State::CDataStarted(s) => self.cdata_started(c, s),
377-
State::InsideComment => self.inside_comment_state(c),
377+
State::InsideComment => Ok(self.inside_comment_state(c)),
378378
State::CommentStarted => self.comment_started(c),
379-
State::InsideProcessingInstruction => self.inside_processing_instruction(c),
380-
State::ProcessingInstructionClosing => self.processing_instruction_closing(c),
379+
State::InsideProcessingInstruction => Ok(self.inside_processing_instruction(c)),
380+
State::ProcessingInstructionClosing => Ok(self.processing_instruction_closing(c)),
381381
State::CommentClosing(s) => self.comment_closing(c, s),
382-
State::CDataClosing(s) => self.cdata_closing(c, s),
383-
State::InsideDoctype => self.inside_doctype(c),
382+
State::CDataClosing(s) => Ok(self.cdata_closing(c, s)),
383+
State::InsideDoctype => Ok(self.inside_doctype(c)),
384384
State::DoctypeStarted(s) => self.doctype_started(c, s),
385-
State::InvalidCDataClosing(s) => self.invalid_cdata_closing(c, s),
385+
State::InvalidCDataClosing(s) => Ok(self.invalid_cdata_closing(c, s)),
386386
State::InsideMarkupDeclaration => self.markup_declaration(c),
387-
State::InsideMarkupDeclarationQuotedString(q) => self.markup_declaration_string(c, q),
387+
State::InsideMarkupDeclarationQuotedString(q) => Ok(self.markup_declaration_string(c, q)),
388388
}
389389
}
390390

391391
#[inline]
392-
fn move_to(&mut self, st: State) -> Result {
392+
fn move_to(&mut self, st: State) -> Option<Token> {
393393
self.st = st;
394-
Ok(None)
394+
None
395395
}
396396

397397
#[inline]
398-
fn move_to_with(&mut self, st: State, token: Token) -> Result {
398+
fn move_to_with(&mut self, st: State, token: Token) -> Option<Token> {
399399
self.st = st;
400-
Ok(Some(token))
400+
Some(token)
401401
}
402402

403403
#[inline]
404-
fn move_to_and_reset_normal(&mut self, st: State, token: Token) -> Result {
404+
fn move_to_and_reset_normal(&mut self, st: State, token: Token) -> Option<Token> {
405405
self.normal_state = st;
406406
self.st = st;
407-
Ok(Some(token))
407+
Some(token)
408408
}
409409

410-
fn move_to_with_unread(&mut self, st: State, cs: &[char], token: Token) -> Result {
410+
fn move_to_with_unread(&mut self, st: State, cs: &[char], token: Token) -> Option<Token> {
411411
for c in cs.iter().rev().copied() {
412412
self.char_queue.push_front(c);
413413
}
@@ -442,77 +442,77 @@ impl Lexer {
442442
let first = chars.next().unwrap_or('\0');
443443
self.char_queue.extend(chars);
444444
self.char_queue.push_back(c);
445-
return self.move_to_with(State::Normal, Token::Character(first));
445+
return Ok(self.move_to_with(State::Normal, Token::Character(first)));
446446
}
447447
Err(self.error(SyntaxError::UnexpectedTokenBefore(chunk, c)))
448448
}
449449

450450
/// Encountered a char
451-
fn normal(&mut self, c: char) -> Result {
451+
fn normal(&mut self, c: char) -> Option<Token> {
452452
match c {
453453
'<' => self.move_to(State::TagStarted),
454-
'>' => Ok(Some(Token::TagEnd)),
454+
'>' => Some(Token::TagEnd),
455455
'/' => self.move_to(State::EmptyTagClosing),
456-
'=' => Ok(Some(Token::EqualsSign)),
457-
'"' => Ok(Some(Token::DoubleQuote)),
458-
'\'' => Ok(Some(Token::SingleQuote)),
456+
'=' => Some(Token::EqualsSign),
457+
'"' => Some(Token::DoubleQuote),
458+
'\'' => Some(Token::SingleQuote),
459459
']' => self.move_to(State::InvalidCDataClosing(ClosingSubstate::First)),
460-
'&' => Ok(Some(Token::ReferenceStart)),
461-
';' => Ok(Some(Token::ReferenceEnd)),
462-
_ => Ok(Some(Token::Character(c)))
460+
'&' => Some(Token::ReferenceStart),
461+
';' => Some(Token::ReferenceEnd),
462+
_ => Some(Token::Character(c))
463463
}
464464
}
465465

466-
fn inside_cdata(&mut self, c: char) -> Result {
466+
fn inside_cdata(&mut self, c: char) -> Option<Token> {
467467
match c {
468468
']' => self.move_to(State::CDataClosing(ClosingSubstate::First)),
469-
_ => Ok(Some(Token::Character(c)))
469+
_ => Some(Token::Character(c)),
470470
}
471471
}
472472

473-
fn inside_processing_instruction(&mut self, c: char) -> Result {
473+
fn inside_processing_instruction(&mut self, c: char) -> Option<Token> {
474474
// These tokens are used by `<?xml?>` parser
475475
match c {
476476
'?' => self.move_to(State::ProcessingInstructionClosing),
477-
'<' => Ok(Some(Token::OpeningTagStart)),
478-
'>' => Ok(Some(Token::TagEnd)),
479-
'/' => Ok(Some(Token::ClosingTagStart)),
480-
'=' => Ok(Some(Token::EqualsSign)),
481-
'"' => Ok(Some(Token::DoubleQuote)),
482-
'\'' => Ok(Some(Token::SingleQuote)),
483-
'&' => Ok(Some(Token::ReferenceStart)),
484-
';' => Ok(Some(Token::ReferenceEnd)),
485-
_ => Ok(Some(Token::Character(c)))
477+
'<' => Some(Token::OpeningTagStart),
478+
'>' => Some(Token::TagEnd),
479+
'/' => Some(Token::ClosingTagStart),
480+
'=' => Some(Token::EqualsSign),
481+
'"' => Some(Token::DoubleQuote),
482+
'\'' => Some(Token::SingleQuote),
483+
'&' => Some(Token::ReferenceStart),
484+
';' => Some(Token::ReferenceEnd),
485+
_ => Some(Token::Character(c))
486486
}
487487
}
488488

489-
fn inside_comment_state(&mut self, c: char) -> Result {
489+
fn inside_comment_state(&mut self, c: char) -> Option<Token> {
490490
match c {
491491
'-' => self.move_to(State::CommentClosing(ClosingSubstate::First)),
492-
_ => Ok(Some(Token::Character(c)))
492+
_ => Some(Token::Character(c)),
493493
}
494494
}
495495

496496
/// Encountered '<'
497497
fn tag_opened(&mut self, c: char) -> Result {
498498
match c {
499-
'?' => self.move_to_with(State::InsideProcessingInstruction, Token::ProcessingInstructionStart),
500-
'/' => self.move_to_with(self.normal_state, Token::ClosingTagStart),
501-
'!' => self.move_to(State::CommentOrCDataOrDoctypeStarted),
502-
_ if is_whitespace_char(c) => self.move_to_with_unread(self.normal_state, &[c], Token::OpeningTagStart),
503-
_ if is_name_char(c) => self.move_to_with_unread(self.normal_state, &[c], Token::OpeningTagStart),
499+
'?' => Ok(self.move_to_with(State::InsideProcessingInstruction, Token::ProcessingInstructionStart)),
500+
'/' => Ok(self.move_to_with(self.normal_state, Token::ClosingTagStart)),
501+
'!' => Ok(self.move_to(State::CommentOrCDataOrDoctypeStarted)),
502+
_ if is_whitespace_char(c) => Ok(self.move_to_with_unread(self.normal_state, &[c], Token::OpeningTagStart)),
503+
_ if is_name_char(c) => Ok(self.move_to_with_unread(self.normal_state, &[c], Token::OpeningTagStart)),
504504
_ => self.handle_error("<", c)
505505
}
506506
}
507507

508508
/// Encountered '<!'
509509
fn comment_or_cdata_or_doctype_started(&mut self, c: char) -> Result {
510510
match c {
511-
'-' => self.move_to(State::CommentStarted),
512-
'[' => self.move_to(State::CDataStarted(CDataStartedSubstate::E)),
513-
'D' => self.move_to(State::DoctypeStarted(DoctypeStartedSubstate::D)),
511+
'-' => Ok(self.move_to(State::CommentStarted)),
512+
'[' => Ok(self.move_to(State::CDataStarted(CDataStartedSubstate::E))),
513+
'D' => Ok(self.move_to(State::DoctypeStarted(DoctypeStartedSubstate::D))),
514514
'E' | 'A' | 'N' if matches!(self.normal_state, State::InsideDoctype) => {
515-
self.move_to_with_unread(State::InsideMarkupDeclaration, &[c], Token::MarkupDeclarationStart)
515+
Ok(self.move_to_with_unread(State::InsideMarkupDeclaration, &[c], Token::MarkupDeclarationStart))
516516
},
517517
_ => self.handle_error("<!", c),
518518
}
@@ -521,7 +521,7 @@ impl Lexer {
521521
/// Encountered '<!-'
522522
fn comment_started(&mut self, c: char) -> Result {
523523
match c {
524-
'-' => self.move_to_with(State::InsideComment, Token::CommentStart),
524+
'-' => Ok(self.move_to_with(State::InsideComment, Token::CommentStart)),
525525
_ => self.handle_error("<!-", c),
526526
}
527527
}
@@ -535,28 +535,28 @@ impl Lexer {
535535
CD ; 'A' ; CDA ; "<![CD",
536536
CDA ; 'T' ; CDAT ; "<![CDA",
537537
CDAT ; 'A' ; CDATA ; "<![CDAT";
538-
CDATA ; '[' ; "<![CDATA" ; self.move_to_with(State::InsideCdata, Token::CDataStart)
538+
CDATA ; '[' ; "<![CDATA" ; Ok(self.move_to_with(State::InsideCdata, Token::CDataStart))
539539
)
540540
}
541541

542542
/// Encountered '<!…' that isn't DOCTYPE or CDATA
543543
fn markup_declaration(&mut self, c: char) -> Result {
544544
match c {
545545
'<' => self.handle_error("<!", c),
546-
'>' => self.move_to_with(self.normal_state, Token::TagEnd),
546+
'>' => Ok(self.move_to_with(self.normal_state, Token::TagEnd)),
547547
'&' => Ok(Some(Token::ReferenceStart)),
548548
';' => Ok(Some(Token::ReferenceEnd)),
549-
'"' => self.move_to_with(State::InsideMarkupDeclarationQuotedString(QuoteStyle::Double), Token::DoubleQuote),
550-
'\'' => self.move_to_with(State::InsideMarkupDeclarationQuotedString(QuoteStyle::Single), Token::SingleQuote),
549+
'"' => Ok(self.move_to_with(State::InsideMarkupDeclarationQuotedString(QuoteStyle::Double), Token::DoubleQuote)),
550+
'\'' => Ok(self.move_to_with(State::InsideMarkupDeclarationQuotedString(QuoteStyle::Single), Token::SingleQuote)),
551551
_ => Ok(Some(Token::Character(c))),
552552
}
553553
}
554554

555-
fn markup_declaration_string(&mut self, c: char, q: QuoteStyle) -> Result {
555+
fn markup_declaration_string(&mut self, c: char, q: QuoteStyle) -> Option<Token> {
556556
match c {
557557
'"' if q == QuoteStyle::Double => self.move_to_with(State::InsideMarkupDeclaration, Token::DoubleQuote),
558558
'\'' if q == QuoteStyle::Single => self.move_to_with(State::InsideMarkupDeclaration, Token::SingleQuote),
559-
_ => Ok(Some(Token::Character(c))),
559+
_ => Some(Token::Character(c)),
560560
}
561561
}
562562

@@ -569,33 +569,33 @@ impl Lexer {
569569
DOC ; 'T' ; DOCT ; "<!DOC",
570570
DOCT ; 'Y' ; DOCTY ; "<!DOCT",
571571
DOCTY ; 'P' ; DOCTYP ; "<!DOCTY";
572-
DOCTYP ; 'E' ; "<!DOCTYP" ; self.move_to_and_reset_normal(State::InsideDoctype, Token::DoctypeStart)
572+
DOCTYP ; 'E' ; "<!DOCTYP" ; Ok(self.move_to_and_reset_normal(State::InsideDoctype, Token::DoctypeStart))
573573
)
574574
}
575575

576576
/// State used while awaiting the closing bracket for the <!DOCTYPE tag
577-
fn inside_doctype(&mut self, c: char) -> Result {
577+
fn inside_doctype(&mut self, c: char) -> Option<Token> {
578578
match c {
579579
'>' => self.move_to_and_reset_normal(State::Normal, Token::TagEnd),
580580
'<' => self.move_to(State::TagStarted),
581-
'&' => Ok(Some(Token::ReferenceStart)),
582-
';' => Ok(Some(Token::ReferenceEnd)),
583-
'"' => Ok(Some(Token::DoubleQuote)),
584-
'\'' => Ok(Some(Token::SingleQuote)),
585-
_ => Ok(Some(Token::Character(c))),
581+
'&' => Some(Token::ReferenceStart),
582+
';' => Some(Token::ReferenceEnd),
583+
'"' => Some(Token::DoubleQuote),
584+
'\'' => Some(Token::SingleQuote),
585+
_ => Some(Token::Character(c)),
586586
}
587587
}
588588

589589
/// Encountered '?'
590-
fn processing_instruction_closing(&mut self, c: char) -> Result {
590+
fn processing_instruction_closing(&mut self, c: char) -> Option<Token> {
591591
match c {
592592
'>' => self.move_to_with(self.normal_state, Token::ProcessingInstructionEnd),
593593
_ => self.move_to_with_unread(State::InsideProcessingInstruction, &[c], Token::Character('?')),
594594
}
595595
}
596596

597597
/// Encountered '/'
598-
fn empty_element_closing(&mut self, c: char) -> Result {
598+
fn empty_element_closing(&mut self, c: char) -> Option<Token> {
599599
match c {
600600
'>' => self.move_to_with(self.normal_state, Token::EmptyTagEnd),
601601
_ => self.move_to_with_unread(self.normal_state, &[c], Token::Character('/')),
@@ -606,19 +606,19 @@ impl Lexer {
606606
fn comment_closing(&mut self, c: char, s: ClosingSubstate) -> Result {
607607
match s {
608608
ClosingSubstate::First => match c {
609-
'-' => self.move_to(State::CommentClosing(ClosingSubstate::Second)),
610-
_ => self.move_to_with_unread(State::InsideComment, &[c], Token::Character('-')),
609+
'-' => Ok(self.move_to(State::CommentClosing(ClosingSubstate::Second))),
610+
_ => Ok(self.move_to_with_unread(State::InsideComment, &[c], Token::Character('-'))),
611611
},
612612
ClosingSubstate::Second => match c {
613-
'>' => self.move_to_with(self.normal_state, Token::CommentEnd),
613+
'>' => Ok(self.move_to_with(self.normal_state, Token::CommentEnd)),
614614
// double dash not followed by a greater-than is a hard error inside comment
615615
_ => self.handle_error("--", c),
616616
},
617617
}
618618
}
619619

620620
/// Encountered ']'
621-
fn cdata_closing(&mut self, c: char, s: ClosingSubstate) -> Result {
621+
fn cdata_closing(&mut self, c: char, s: ClosingSubstate) -> Option<Token> {
622622
match s {
623623
ClosingSubstate::First => match c {
624624
']' => self.move_to(State::CDataClosing(ClosingSubstate::Second)),
@@ -632,7 +632,7 @@ impl Lexer {
632632
}
633633

634634
/// Encountered ']'
635-
fn invalid_cdata_closing(&mut self, c: char, s: ClosingSubstate) -> Result {
635+
fn invalid_cdata_closing(&mut self, c: char, s: ClosingSubstate) -> Option<Token> {
636636
match s {
637637
ClosingSubstate::First => match c {
638638
']' => self.move_to(State::InvalidCDataClosing(ClosingSubstate::Second)),

‎src/reader/parser.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -260,7 +260,7 @@ pub enum DeclarationSubstate {
260260
AfterStandaloneDeclValue,
261261
}
262262

263-
#[derive(PartialEq)]
263+
#[derive(Copy, Clone, PartialEq)]
264264
enum QualifiedNameTarget {
265265
AttributeNameTarget,
266266
OpeningTagNameTarget,

‎tests/xmlconf.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
//! W3C XML conformance test suite https://www.w3.org/XML/Test/
1+
//! W3C XML conformance test suite <https://www.w3.org/XML/Test/>
22
33
use std::collections::HashMap;
44
use std::collections::HashSet;

0 commit comments

Comments
 (0)