@@ -305,22 +305,58 @@ struct Visitor<'a> {
305305}
306306
307307impl Visitor < ' _ > {
308+ fn record_parse_error (
309+ & mut self ,
310+ error_message : String ,
311+ full_error_message : String ,
312+ loc : Label ,
313+ ) {
314+ error ! ( "{}" , full_error_message) ;
315+ let id = self . trap_writer . fresh_id ( ) ;
316+ self . trap_writer . add_tuple (
317+ "diagnostics" ,
318+ vec ! [
319+ Arg :: Label ( id) ,
320+ Arg :: Int ( 40 ) , // severity 40 = error
321+ Arg :: String ( "parse_error" . to_string( ) ) ,
322+ Arg :: String ( error_message) ,
323+ Arg :: String ( full_error_message) ,
324+ Arg :: Label ( loc) ,
325+ ] ,
326+ ) ;
327+ }
328+
329+ fn record_parse_error_for_node (
330+ & mut self ,
331+ error_message : String ,
332+ full_error_message : String ,
333+ node : Node ,
334+ ) {
335+ let ( start_line, start_column, end_line, end_column) = location_for ( & self . source , node) ;
336+ let loc = self . trap_writer . location (
337+ self . file_label ,
338+ start_line,
339+ start_column,
340+ end_line,
341+ end_column,
342+ ) ;
343+ self . record_parse_error ( error_message, full_error_message, loc) ;
344+ }
345+
308346 fn enter_node ( & mut self , node : Node ) -> bool {
309- if node. is_error ( ) {
310- error ! (
311- "{}:{}: parse error" ,
312- & self . path,
313- node. start_position( ) . row + 1
314- ) ;
315- return false ;
316- }
317- if node. is_missing ( ) {
318- error ! (
319- "{}:{}: parse error: expecting '{}'" ,
347+ if node. is_error ( ) || node. is_missing ( ) {
348+ let error_message = if node. is_missing ( ) {
349+ format ! ( "parse error: expecting '{}'" , node. kind( ) )
350+ } else {
351+ "parse error" . to_string ( )
352+ } ;
353+ let full_error_message = format ! (
354+ "{}:{}: {}" ,
320355 & self . path,
321356 node. start_position( ) . row + 1 ,
322- node . kind ( )
357+ error_message
323358 ) ;
359+ self . record_parse_error_for_node ( error_message, full_error_message, node) ;
324360 return false ;
325361 }
326362
@@ -405,12 +441,15 @@ impl Visitor<'_> {
405441 }
406442 }
407443 _ => {
408- error ! (
409- "{}:{}: unknown table type: '{}'" ,
444+ let error_message = format ! ( "unknown table type: '{}'" , node. kind( ) ) ;
445+ let full_error_message = format ! (
446+ "{}:{}: {}" ,
410447 & self . path,
411448 node. start_position( ) . row + 1 ,
412- node . kind ( )
449+ error_message
413450 ) ;
451+ self . record_parse_error ( error_message, full_error_message, loc) ;
452+
414453 valid = false ;
415454 }
416455 }
@@ -456,26 +495,36 @@ impl Visitor<'_> {
456495 values. push ( Arg :: Label ( child_node. label ) ) ;
457496 }
458497 } else if field. name . is_some ( ) {
459- error ! (
460- "{}:{}: type mismatch for field {}::{} with type {:?} != {:?}" ,
461- & self . path,
462- node. start_position( ) . row + 1 ,
498+ let error_message = format ! (
499+ "type mismatch for field {}::{} with type {:?} != {:?}" ,
463500 node. kind( ) ,
464501 child_node. field_name. unwrap_or( "child" ) ,
465502 child_node. type_name,
466503 field. type_info
467- )
504+ ) ;
505+ let full_error_message = format ! (
506+ "{}:{}: {}" ,
507+ & self . path,
508+ node. start_position( ) . row + 1 ,
509+ error_message
510+ ) ;
511+ self . record_parse_error_for_node ( error_message, full_error_message, * node) ;
468512 }
469513 } else {
470514 if child_node. field_name . is_some ( ) || child_node. type_name . named {
471- error ! (
472- "{}:{}: value for unknown field: {}::{} and type {:?}" ,
473- & self . path,
474- node. start_position( ) . row + 1 ,
515+ let error_message = format ! (
516+ "value for unknown field: {}::{} and type {:?}" ,
475517 node. kind( ) ,
476518 & child_node. field_name. unwrap_or( "child" ) ,
477519 & child_node. type_name
478520 ) ;
521+ let full_error_message = format ! (
522+ "{}:{}: {}" ,
523+ & self . path,
524+ node. start_position( ) . row + 1 ,
525+ error_message
526+ ) ;
527+ self . record_parse_error_for_node ( error_message, full_error_message, * node) ;
479528 }
480529 }
481530 }
@@ -489,18 +538,23 @@ impl Visitor<'_> {
489538 args. push ( child_values. first ( ) . unwrap ( ) . clone ( ) ) ;
490539 } else {
491540 is_valid = false ;
492- error ! (
493- "{}:{}: {} for field: {}::{}" ,
494- & self . path,
495- node. start_position( ) . row + 1 ,
541+ let error_message = format ! (
542+ "{} for field: {}::{}" ,
496543 if child_values. is_empty( ) {
497544 "missing value"
498545 } else {
499546 "too many values"
500547 } ,
501548 node. kind( ) ,
502549 column_name
503- )
550+ ) ;
551+ let full_error_message = format ! (
552+ "{}:{}: {}" ,
553+ & self . path,
554+ node. start_position( ) . row + 1 ,
555+ error_message
556+ ) ;
557+ self . record_parse_error_for_node ( error_message, full_error_message, * node) ;
504558 }
505559 }
506560 Storage :: Table {
0 commit comments