@@ -558,6 +558,81 @@ fn translation_rules() -> Vec<yeast::Rule> {
558558 let name = __yeast_ctx. literal( "identifier" , & text[ ..text. len( ) - 1 ] ) ;
559559 vec![ __yeast_ctx. node( "labeled_stmt" , vec![ ( "label" , vec![ name] ) , ( "stmt" , vec![ stmt. into( ) ] ) ] ) ]
560560 } } ) ,
561+ // ---- Collections ----
562+ // Array literal
563+ rule!( ( array_literal element: _* @elems) => ( array_literal element: { ..elems} ) ) ,
564+ // Empty array literal
565+ rule!( ( array_literal) => ( array_literal) ) ,
566+ // Dictionary literal — zip keys and values into key_value_pairs
567+ rule!(
568+ ( dictionary_literal key: _* @keys value: _* @vals)
569+ =>
570+ ( map_literal element: { ..{
571+ keys. iter( ) . zip( vals. iter( ) ) . map( |( & k, & v) | {
572+ let k_id: usize = k. into( ) ;
573+ let v_id: usize = v. into( ) ;
574+ __yeast_ctx. node( "key_value_pair" , vec![
575+ ( "key" , vec![ k_id] ) ,
576+ ( "value" , vec![ v_id] ) ,
577+ ] )
578+ } ) . collect:: <Vec <_>>( )
579+ } } )
580+ ) ,
581+ rule!( ( dictionary_literal element: _* @elems) => ( map_literal element: { ..elems} ) ) ,
582+ rule!( ( dictionary_literal_item key: @k value: @v) => ( key_value_pair key: { k} value: { v} ) ) ,
583+ // ---- Optionals and errors ----
584+ // Optional chaining — unwrap the marker
585+ rule!( ( optional_chain_marker expr: @inner) => { inner} ) ,
586+ // try/try?/try! expr → unary_expr with operator "try", "try?" or "try!"
587+ rule!( ( try_expression ( try_operator) @op expr: @inner) => ( unary_expr operator: ( prefix_operator #{ op} ) operand: { inner} ) ) ,
588+ rule!( ( try_expression operator: ( try_operator) @op expr: @inner) => ( unary_expr operator: ( prefix_operator #{ op} ) operand: { inner} ) ) ,
589+ // Do-catch → try_expr
590+ rule!(
591+ ( do_statement body: ( block statement: _* @body) catch: ( catch_block) * @catches)
592+ =>
593+ ( try_expr
594+ body: ( block stmt: { ..body} )
595+ catch_clause: { ..catches} )
596+ ) ,
597+ // Catch block with bound identifier; optional where-clause guard.
598+ rule!(
599+ ( catch_block
600+ keyword: ( catch_keyword)
601+ error: @pattern
602+ where : ( where_clause expr: @guard) ?
603+ body: ( block statement: _* @body) )
604+ =>
605+ ( catch_clause
606+ pattern: { pattern}
607+ guard: { ..guard}
608+ body: ( block stmt: { ..body} ) )
609+ ) ,
610+ // Catch block without error binding
611+ rule!(
612+ ( catch_block keyword: ( catch_keyword) body: ( block statement: _* @body) )
613+ =>
614+ ( catch_clause body: ( block stmt: { ..body} ) )
615+ ) ,
616+ // Empty catch block: catch {}
617+ rule!(
618+ ( catch_block ( catch_keyword) )
619+ =>
620+ ( catch_clause body: ( block) )
621+ ) ,
622+ // Catch block with unhandled pattern — preserve pattern; optional body.
623+ rule!(
624+ ( catch_block keyword: ( catch_keyword) error: @pat body: ( block statement: _* @body) )
625+ =>
626+ ( catch_clause
627+ pattern: { pat}
628+ body: ( block stmt: { ..body} ) )
629+ ) ,
630+ // As expression (type cast) — as?, as!
631+ rule!( ( as_expression ( as_operator) @op expr: @val type : @ty) => ( type_cast_expr expr: { val} operator: ( infix_operator #{ op} ) type : { ty} ) ) ,
632+ // Check expression (`x is T`) → type_test_expr
633+ rule!( ( check_expression op: @op target: @val type : @ty) => ( type_test_expr expr: { val} operator: ( infix_operator #{ op} ) type : { ty} ) ) ,
634+ // Await expression → unary_expr with operator "await"
635+ rule!( ( await_expression expr: @val) => ( unary_expr operator: ( prefix_operator "await" ) operand: { val} ) ) ,
561636 // ---- Fallbacks ----
562637 rule!(
563638 ( _)
0 commit comments