git.delta.rocks / jrsonnet / refs/commits / da64a7455472

647fn format(input: &str, opts: &FormatOptions) -> Option<String> {647fn format(input: &str, opts: &FormatOptions) -> Option<String> {
648	let (parsed, errors) = jrsonnet_rowan_parser::parse(input);648	let (parsed, errors) = jrsonnet_rowan_parser::parse(input);
649	if !errors.is_empty() {649	if !errors.is_empty() {
650		let mut builder = ass_stroke::SnippetBuilder::new(input);650		let mut builder = hi_doc::SnippetBuilder::new(input);
651		for error in errors {651		for error in errors {
652			builder652			builder
653				.error(ass_stroke::Text::single(653				.error(hi_doc::Text::single(
654					format!("{:?}", error.error).chars(),654					format!("{:?}", error.error).chars(),
655					Default::default(),655					Default::default(),
656				))656				))
661				.build();661				.build();
662		}662		}
663		let snippet = builder.build();663		let snippet = builder.build();
664		let ansi = ass_stroke::source_to_ansi(&snippet);664		let ansi = hi_doc::source_to_ansi(&snippet);
665		eprintln!("{ansi}");665		eprintln!("{ansi}");
666		// It is possible to recover from this failure, but the output may be broken, as formatter is free to skip666		// It is possible to recover from this failure, but the output may be broken, as formatter is free to skip
667		// ERROR rowan nodes.667		// ERROR rowan nodes.

135	MULTI_LINE_COMMENT,135	MULTI_LINE_COMMENT,
136	#[regex("/\\*/")]136	#[regex("/\\*/")]
137	ERROR_COMMENT_TOO_SHORT,137	ERROR_COMMENT_TOO_SHORT,
138	#[regex("/\\*([^*]|\\*[^/])+")]138	#[regex("/\\*([^*/]|\\*[^/])+")]
139	ERROR_COMMENT_UNTERMINATED,139	ERROR_COMMENT_UNTERMINATED,
140	#[token("tailstrict")]140	#[token("tailstrict")]
141	TAILSTRICT_KW,141	TAILSTRICT_KW,
178	ERROR_MISSING_TOKEN,178	ERROR_MISSING_TOKEN,
179	ERROR_UNEXPECTED_TOKEN,179	ERROR_UNEXPECTED_TOKEN,
180	ERROR_CUSTOM,180	ERROR_CUSTOM,
181	#[doc = r" Also acts as __LAST_TOKEN"]
182	#[error]
183	LEXING_ERROR,181	LEXING_ERROR,
182	__LAST_TOKEN,
184	SOURCE_FILE,183	SOURCE_FILE,
185	EXPR,184	EXPR,
186	SUFFIX_INDEX,185	SUFFIX_INDEX,

30		let mut kind = self.inner.next()?;30		let mut kind = self.inner.next()?;
31		let text = self.inner.slice();31		let text = self.inner.slice();
3232
33		if kind == STRING_BLOCK {33		if kind == Ok(STRING_BLOCK) {
34			// We use custom lexer, which skips enough bytes, but not returns error34			// We use custom lexer, which skips enough bytes, but not returns error
35			// Instead we should call lexer again to verify if there is something wrong with string block35			// Instead we should call lexer again to verify if there is something wrong with string block
36			let mut lexer = logos::Lexer::<SyntaxKind>::new(text);36			let mut lexer = logos::Lexer::<SyntaxKind>::new(text);
41			match res {41			match res {
42				Ok(_) => {}42				Ok(_) => {}
43				Err(e) => {43				Err(e) => {
44					kind = match e {44					kind = Ok(match e {
45						StringBlockError::UnexpectedEnd => ERROR_STRING_BLOCK_UNEXPECTED_END,45						StringBlockError::UnexpectedEnd => ERROR_STRING_BLOCK_UNEXPECTED_END,
46						StringBlockError::MissingNewLine => ERROR_STRING_BLOCK_MISSING_NEW_LINE,46						StringBlockError::MissingNewLine => ERROR_STRING_BLOCK_MISSING_NEW_LINE,
47						StringBlockError::MissingTermination => {47						StringBlockError::MissingTermination => {
48							ERROR_STRING_BLOCK_MISSING_TERMINATION48							ERROR_STRING_BLOCK_MISSING_TERMINATION
49						}49						}
50						StringBlockError::MissingIndent => ERROR_STRING_BLOCK_MISSING_INDENT,50						StringBlockError::MissingIndent => ERROR_STRING_BLOCK_MISSING_INDENT,
51					}51					})
52				}52				}
53			}53			}
54		}54		}
5555
56		Some(Self::Item {56		Some(Self::Item {
57			kind,57			kind: kind.unwrap_or(SyntaxKind::LEXING_ERROR),
58			text,58			text,
59			range: {59			range: {
60				let Range { start, end } = self.inner.span();60				let Range { start, end } = self.inner.span();

57	fn from(val: LocatedSyntaxError) -> Self {57	fn from(val: LocatedSyntaxError) -> Self {
58		let span = SourceSpan::new(58		let span = SourceSpan::new(
59			SourceOffset::from(usize::from(val.range.start())),59			SourceOffset::from(usize::from(val.range.start())),
60			SourceOffset::from(usize::from(val.range.end() - val.range.start())),60			usize::from(val.range.end() - val.range.start()),
61		);61		);
62		dbg!(&val);62		dbg!(&val);
63		match val.error {63		match val.error {

65LocatedSyntaxError { error: Custom { error: "unexpected tokens after end" }, range: 29..67 }65LocatedSyntaxError { error: Custom { error: "unexpected tokens after end" }, range: 29..67 }
66===66===
67  x syntax error67  x syntax error
68   ,-[1:1]68   ,-[1:15]
69 1 | ,-> local intr = $intrinsic(test);69 1 | ,-> local intr = $intrinsic(test);
70   : ||              ^^^^|^^^^70   : |                 ^^^^|^^^^
71   : ||                  `-- expected L_BRACK, L_PAREN, L_BRACE, SEMI, DOT, COMMA or QUESTION_MARK, found IDENT71   : |                     `-- expected L_BRACK, L_PAREN, L_BRACE, SEMI, DOT, COMMA or QUESTION_MARK, found IDENT
72 2 | |72 2 | |
73 3 | |   local a = 1, b = 2, c = a + b;73 3 | |   local a = 1, b = 2, c = a + b;
74 4 | |74 4 | |

40LocatedSyntaxError { error: Missing { expected: Named("expression") }, range: 25..25 }40LocatedSyntaxError { error: Missing { expected: Named("expression") }, range: 25..25 }
41===41===
42  x syntax error42  x syntax error
43   ,-[2:1]43   ,-[3:3]
44 2 | local b = 3;44 2 | local b = 3;
45 3 | 145 3 | 1
46   :   ^^46   :   ^^

26LocatedSyntaxError { error: Unexpected { expected: Named("destruction specifier"), found: MUL }, range: 6..7 }26LocatedSyntaxError { error: Unexpected { expected: Named("destruction specifier"), found: MUL }, range: 6..7 }
27===27===
28  x syntax error28  x syntax error
29   ,-[1:1]29   ,-[1:7]
30 1 | local * = 1;30 1 | local * = 1;
31   :       |31   :       |
32   :       `-- expected destruction specifier, found MUL32   :       `-- expected destruction specifier, found MUL

39LocatedSyntaxError { error: Unexpected { expected: Named("comma"), found: SEMI }, range: 14..15 }39LocatedSyntaxError { error: Unexpected { expected: Named("comma"), found: SEMI }, range: 14..15 }
40===40===
41  x syntax error41  x syntax error
42   ,-[1:1]42   ,-[2:6]
43 1 | {43 1 | {
44 2 |     a: 1;44 2 |     a: 1;
45   :         |45   :         |

273		lit("SINGLE_LINE_HASH_COMMENT") => r"#[^\r\n]*(\r\n|\n)?";273		lit("SINGLE_LINE_HASH_COMMENT") => r"#[^\r\n]*(\r\n|\n)?";
274		lit("MULTI_LINE_COMMENT") => r"/\*([^*]|\*[^/])*\*/";274		lit("MULTI_LINE_COMMENT") => r"/\*([^*]|\*[^/])*\*/";
275		error("COMMENT_TOO_SHORT") => r"/\*/";275		error("COMMENT_TOO_SHORT") => r"/\*/";
276		error("COMMENT_UNTERMINATED") =>  r"/\*([^*]|\*[^/])+";276		error("COMMENT_UNTERMINATED") =>  r"/\*([^*/]|\*[^/])+";
277	];277	];
278	kinds278	kinds
279}279}

149			#[doc(hidden)]149			#[doc(hidden)]
150			EOF,150			EOF,
151			#(#token_kinds,)*151			#(#token_kinds,)*
152			/// Also acts as __LAST_TOKEN
153			#[error]
154			LEXING_ERROR,152			LEXING_ERROR,
153			__LAST_TOKEN,
155			#(#nodes,)*154			#(#nodes,)*
156			#[doc(hidden)]155			#[doc(hidden)]
157			__LAST,156			__LAST,