19957094785

Committed 05 Dec 2025 08:23AM UTC coverage: 86.918% (+8.5%) from 78.463%

Build # 19957094785

Build Type

Pull #837

github

Committed by

web-flow

Commit Message

Merge dec08367a into 2f840d387

Pull Request Pull Request #837: Split TransactionHintsBag hints properly

Run Details

44 of 53 new or added lines in 13 files covered. (83.02%)

1621 existing lines in 221 files now uncovered.

27453 of 31585 relevant lines covered (86.92%)

253204.4 hits per line

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

96.43

/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 {	32✔
34	Self {	32✔
35	source,	32✔
36	events: Vec::new(),	32✔
37	expected_kinds: Vec::new(),	32✔
38	}	32✔
39	}	32✔
40
41	pub fn parse(mut self) -> Vec<Event> {	32✔
42	grammar::root(&mut self);	32✔
43	self.events	32✔
44	}	32✔
45
46	fn start(&mut self) -> Marker {	109✔
47	let pos = self.events.len();	109✔
48	self.events.push(Event::Placeholder);	109✔
49
50	Marker::new(pos)	109✔
51	}	109✔
52
53	fn expect(&mut self, kind: TokenKind) {	10✔
54	if self.at(kind) {	10✔
55	self.bump();	9✔
56	} else {	9✔
57	self.error();	1✔
58	}	1✔
59	}	10✔
60
61	fn error(&mut self) {	3✔
62	let current_token = self.source.peek_token();	3✔
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())	2✔
70	};
71
72	self.events.push(Event::Error(ParseError {	3✔
73	expected: mem::take(&mut self.expected_kinds),	3✔
74	found,	3✔
75	span: range,	3✔
76	}));	3✔
77
78	// if !self.at_set(&RECOVERY_SET) && !self.at_end() {
79	if !self.at_end() {	3✔
80	let m = self.start();	1✔
81	self.bump();	1✔
82	m.complete(self, SyntaxKind::Error);	1✔
83	}	2✔
84	}	3✔
85
86	fn bump(&mut self) {	86✔
87	self.expected_kinds.clear();	86✔
88	self.source.next_token().unwrap();	86✔
89	self.events.push(Event::AddToken);	86✔
90	}	86✔
91
92	fn at(&mut self, kind: TokenKind) -> bool {	467✔
93	self.expected_kinds.push(kind);	467✔
94	self.peek() == Some(kind)	467✔
95	}	467✔
96
97	fn at_set(&mut self, set: &[TokenKind]) -> bool {	×
98	self.peek().is_some_and(\|k\| set.contains(&k))	×
UNCOV 99	}	×
100
101	fn at_end(&mut self) -> bool {	66✔
102	self.peek().is_none()	66✔
103	}	66✔
104
105	fn peek(&mut self) -> Option<TokenKind> {	533✔
106	self.source.peek_kind()	533✔
107	}	533✔
108	}
109
110	#[cfg(test)]
111	fn check(input: &str, expected_tree: expect_test::Expect) {	21✔
112	let parse = parse::parse(input);	21✔
113	expected_tree.assert_eq(&parse.debug_tree());	21✔
114	}	21✔
115
116	#[cfg(test)]
117	mod tests {
118	use crate::parser::check;
119	use expect_test::expect;
120
121	#[test]
122	fn parse_nothing() {	1✔
123	check("", expect![[r#"Root@0..0"#]]);	1✔
124	}	1✔
125
126	#[test]
127	fn parse_whitespace() {	1✔
128	check(	1✔
129	" ",	1✔
130	expect![[r#"	1✔
131	Root@0..3
132	Whitespace@0..3 " ""#]],
133	);
134	}	1✔
135
136	#[test]
137	fn parse_comment() {	1✔
138	check(	1✔
139	"// hello!",	1✔
140	expect![[r#"	1✔
141	Root@0..9
142	Comment@0..9 "// hello!""#]],
143	);
144	}	1✔
145
146	#[test]
147	fn parse_int_literal() {	1✔
148	check(	1✔
149	"42",	1✔
150	expect![[r#"	1✔
151	Root@0..2
152	IntNumber@0..2
153	IntNumber@0..2 "42""#]],
154	);
155	}	1✔
156
157	#[test]
158	fn parse_long_literal() {	1✔
159	check(	1✔
160	"42L",	1✔
161	expect![[r#"	1✔
162	Root@0..3
163	LongNumber@0..3
164	LongNumber@0..3 "42L""#]],
165	);
166	}	1✔
167	}

ergoplatform / sigma-rust / 19957094785

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