15655622355

Committed 14 Jun 2025 08:01PM UTC coverage: 78.291% (-0.1%) from 78.39%

Build # 15655622355

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #833 from sethdusek/rust1.87

Bump rust-toolchain to rust 1.87

Run Details

9 of 11 new or added lines in 7 files covered. (81.82%)

25 existing lines in 3 files now uncovered.

11721 of 14971 relevant lines covered (78.29%)

2.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.7

/ergoscript-compiler/src/parser.rs

#![allow(dead_code)]

mod event;
mod grammar;
mod marker;
mod parse;
pub(crate) mod parse_error;
mod sink;
mod source;

pub(crate) use parse::parse;

use std::mem;

use crate::lexer::Token;
use crate::lexer::TokenKind;
use crate::syntax::SyntaxKind;

use self::event::Event;
use self::marker::Marker;
use self::parse_error::ParseError;
use self::source::Source;

// const RECOVERY_SET: [TokenKind; 1] = [TokenKind::ValKw];

pub struct Parser<'t, 'input> {
    pub source: Source<'t, 'input>,
    pub events: Vec<Event>,
    pub expected_kinds: Vec<TokenKind>,
}

impl<'t, 'input> Parser<'t, 'input> {
    pub fn new(source: Source<'t, 'input>) -> Self {
        Self {
            source,
            events: Vec::new(),
            expected_kinds: Vec::new(),
        }
    }

    pub fn parse(mut self) -> Vec<Event> {
        grammar::root(&mut self);
        self.events
    }

    fn start(&mut self) -> Marker {
        let pos = self.events.len();
        self.events.push(Event::Placeholder);

        Marker::new(pos)
    }

    fn expect(&mut self, kind: TokenKind) {
        if self.at(kind) {
            self.bump();
        } else {
            self.error();
        }
    }

    fn error(&mut self) {
        let current_token = self.source.peek_token();

        let (found, range) = if let Some(Token { kind, range, .. }) = current_token {
            (Some(*kind), *range)
        } else {
            // If we’re at the end of the input we use the range of the very last token in the
            // input.
            (None, self.source.last_token_range().unwrap())
        };

        self.events.push(Event::Error(ParseError {
            expected: mem::take(&mut self.expected_kinds),
            found,
            span: range,
        }));

        // if !self.at_set(&RECOVERY_SET) && !self.at_end() {
        if !self.at_end() {
            let m = self.start();
            self.bump();
            m.complete(self, SyntaxKind::Error);
        }
    }

    fn bump(&mut self) {
        self.expected_kinds.clear();
        self.source.next_token().unwrap();
        self.events.push(Event::AddToken);
    }

    fn at(&mut self, kind: TokenKind) -> bool {
        self.expected_kinds.push(kind);
        self.peek() == Some(kind)
    }

    fn at_set(&mut self, set: &[TokenKind]) -> bool {
        self.peek().is_some_and(|k| set.contains(&k))
    }

    fn at_end(&mut self) -> bool {
        self.peek().is_none()
    }

    fn peek(&mut self) -> Option<TokenKind> {
        self.source.peek_kind()
    }
}

#[cfg(test)]
fn check(input: &str, expected_tree: expect_test::Expect) {
    let parse = parse::parse(input);
    expected_tree.assert_eq(&parse.debug_tree());
}

#[cfg(test)]
mod tests {
    use crate::parser::check;
    use expect_test::expect;

    #[test]
    fn parse_nothing() {
        check("", expect![[r#"Root@0..0"#]]);
    }

    #[test]
    fn parse_whitespace() {
        check(
            "   ",
            expect![[r#"
            Root@0..3
              Whitespace@0..3 "   ""#]],
        );
    }

    #[test]
    fn parse_comment() {
        check(
            "// hello!",
            expect![[r#"
            Root@0..9
              Comment@0..9 "// hello!""#]],
        );
    }

    #[test]
    fn parse_int_literal() {
        check(
            "42",
            expect![[r#"
                Root@0..2
                  IntNumber@0..2
                    IntNumber@0..2 "42""#]],
        );
    }

    #[test]
    fn parse_long_literal() {
        check(
            "42L",
            expect![[r#"
                Root@0..3
                  LongNumber@0..3
                    LongNumber@0..3 "42L""#]],
        );
    }
}

1	#![allow(dead_code)]
2
3	mod event;
4	mod grammar;
5	mod marker;
6	mod parse;
7	pub(crate) mod parse_error;
8	mod sink;
9	mod source;
10
11	pub(crate) use parse::parse;
12
13	use std::mem;
14
15	use crate::lexer::Token;
16	use crate::lexer::TokenKind;
17	use crate::syntax::SyntaxKind;
18
19	use self::event::Event;
20	use self::marker::Marker;
21	use self::parse_error::ParseError;
22	use self::source::Source;
23
24	// const RECOVERY_SET: [TokenKind; 1] = [TokenKind::ValKw];
25
26	pub struct Parser<'t, 'input> {
27	pub source: Source<'t, 'input>,
28	pub events: Vec<Event>,
29	pub expected_kinds: Vec<TokenKind>,
30	}
31
32	impl<'t, 'input> Parser<'t, 'input> {
33	pub fn new(source: Source<'t, 'input>) -> Self {	6✔
34	Self {
35	source,
36	events: Vec::new(),	6✔
37	expected_kinds: Vec::new(),	6✔
38	}
39	}
40
41	pub fn parse(mut self) -> Vec<Event> {	6✔
42	grammar::root(&mut self);	6✔
43	self.events	3✔
44	}
45
46	fn start(&mut self) -> Marker {	6✔
47	let pos = self.events.len();	6✔
48	self.events.push(Event::Placeholder);	6✔
49
50	Marker::new(pos)	6✔
51	}
52
53	fn expect(&mut self, kind: TokenKind) {	1✔
54	if self.at(kind) {	1✔
55	self.bump();	1✔
56	} else {
57	self.error();	1✔
58	}
59	}
60
61	fn error(&mut self) {	1✔
62	let current_token = self.source.peek_token();	1✔
63
64	let (found, range) = if let Some(Token { kind, range, .. }) = current_token {	3✔
65	(Some(kind), range)	1✔
66	} else {
67	// If we’re at the end of the input we use the range of the very last token in the
68	// input.
69	(None, self.source.last_token_range().unwrap())	1✔
70	};
71
72	self.events.push(Event::Error(ParseError {	1✔
73	expected: mem::take(&mut self.expected_kinds),	1✔
74	found,	×
75	span: range,	×
76	}));
77
78	// if !self.at_set(&RECOVERY_SET) && !self.at_end() {
79	if !self.at_end() {	2✔
80	let m = self.start();	1✔
81	self.bump();	1✔
82	m.complete(self, SyntaxKind::Error);	1✔
83	}
84	}
85
86	fn bump(&mut self) {	3✔
87	self.expected_kinds.clear();	3✔
88	self.source.next_token().unwrap();	3✔
89	self.events.push(Event::AddToken);	5✔
90	}
91
92	fn at(&mut self, kind: TokenKind) -> bool {	5✔
93	self.expected_kinds.push(kind);	3✔
94	self.peek() == Some(kind)	5✔
95	}
96
97	fn at_set(&mut self, set: &[TokenKind]) -> bool {	×
NEW 98	self.peek().is_some_and(\|k\| set.contains(&k))	×
99	}
100
101	fn at_end(&mut self) -> bool {	6✔
102	self.peek().is_none()	6✔
103	}
104
105	fn peek(&mut self) -> Option<TokenKind> {	6✔
106	self.source.peek_kind()	6✔
107	}
108	}
109
110	#[cfg(test)]
111	fn check(input: &str, expected_tree: expect_test::Expect) {	1✔
112	let parse = parse::parse(input);	1✔
113	expected_tree.assert_eq(&parse.debug_tree());	2✔
114	}
115
116	#[cfg(test)]
117	mod tests {
118	use crate::parser::check;
119	use expect_test::expect;
120
121	#[test]
122	fn parse_nothing() {
123	check("", expect![[r#"Root@0..0"#]]);
124	}
125
126	#[test]
127	fn parse_whitespace() {
128	check(
129	" ",
130	expect![[r#"
131	Root@0..3
132	Whitespace@0..3 " ""#]],
133	);
134	}
135
136	#[test]
137	fn parse_comment() {
138	check(
139	"// hello!",
140	expect![[r#"
141	Root@0..9
142	Comment@0..9 "// hello!""#]],
143	);
144	}
145
146	#[test]
147	fn parse_int_literal() {
148	check(
149	"42",
150	expect![[r#"
151	Root@0..2
152	IntNumber@0..2
153	IntNumber@0..2 "42""#]],
154	);
155	}
156
157	#[test]
158	fn parse_long_literal() {
159	check(
160	"42L",
161	expect![[r#"
162	Root@0..3
163	LongNumber@0..3
164	LongNumber@0..3 "42L""#]],
165	);
166	}
167	}

ergoplatform / sigma-rust / 15655622355

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous