[INFO] crate haru 0.29.5 is already in cache
[INFO] checking haru-0.29.5 against master#bf1f2eedda4fa02b7c9347dd849ed73ddd43dedc for pr-70917
[INFO] extracting crate haru 0.29.5 into /workspace/builds/worker-6/source
[INFO] validating manifest of crates.io crate haru 0.29.5 on toolchain bf1f2eedda4fa02b7c9347dd849ed73ddd43dedc
[INFO] running `"/workspace/cargo-home/bin/cargo" "+bf1f2eedda4fa02b7c9347dd849ed73ddd43dedc" "read-manifest" "--manifest-path" "Cargo.toml"`
[INFO] started tweaking crates.io crate haru 0.29.5
[INFO] finished tweaking crates.io crate haru 0.29.5
[INFO] tweaked toml for crates.io crate haru 0.29.5 written to /workspace/builds/worker-6/source/Cargo.toml
[INFO] running `"/workspace/cargo-home/bin/cargo" "+bf1f2eedda4fa02b7c9347dd849ed73ddd43dedc" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"`
[INFO] running `"/workspace/cargo-home/bin/cargo" "+bf1f2eedda4fa02b7c9347dd849ed73ddd43dedc" "fetch" "--locked" "--manifest-path" "Cargo.toml"`
[INFO] running `"docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "MAP_USER_ID=0" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--network" "none" "rustops/crates-build-env" "/opt/rustwide/cargo-home/bin/cargo" "+bf1f2eedda4fa02b7c9347dd849ed73ddd43dedc" "check" "--frozen" "--all" "--all-targets"`
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] [stdout] 68a39209636d3087ed5823004ec7245b4558065ecddb2056321f3d9ea774f56e
[INFO] running `"docker" "start" "-a" "68a39209636d3087ed5823004ec7245b4558065ecddb2056321f3d9ea774f56e"`
[INFO] [stderr]    Compiling nix v0.13.1
[INFO] [stderr]     Checking utf8parse v0.1.1
[INFO] [stderr]     Checking hashbrown v0.4.0
[INFO] [stderr]    Compiling haru-decorator v0.21.0
[INFO] [stderr]    Compiling num-derive v0.2.5
[INFO] [stderr]    Compiling haru v0.29.5 (/opt/rustwide/workdir)
[INFO] [stderr]     Checking rustyline v4.1.0
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:165:18
[INFO] [stderr]     |
[INFO] [stderr] 165 |                 0...0xff => {
[INFO] [stderr]     |                  ^^^ help: use `..=` for an inclusive range
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(ellipsis_inclusive_range_patterns)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:169:22
[INFO] [stderr]     |
[INFO] [stderr] 169 |                 0x100...0xffff => {
[INFO] [stderr]     |                      ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:173:24
[INFO] [stderr]     |
[INFO] [stderr] 173 |                 0x10000...0xffffffff => {
[INFO] [stderr]     |                        ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:211:40
[INFO] [stderr]     |
[INFO] [stderr] 211 |         pub exprs: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(bare_trait_objects)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:244:35
[INFO] [stderr]     |
[INFO] [stderr] 244 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:316:40
[INFO] [stderr]     |
[INFO] [stderr] 316 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:371:34
[INFO] [stderr]     |
[INFO] [stderr] 371 |         pub val: std::boxed::Box<AST>,
[INFO] [stderr]     |                                  ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:400:35
[INFO] [stderr]     |
[INFO] [stderr] 400 |         pub cond: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:401:35
[INFO] [stderr]     |
[INFO] [stderr] 401 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:402:34
[INFO] [stderr]     |
[INFO] [stderr] 402 |         pub alt: std::boxed::Box<AST>,
[INFO] [stderr]     |                                  ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:498:35
[INFO] [stderr]     |
[INFO] [stderr] 498 |         pub left: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:499:36
[INFO] [stderr]     |
[INFO] [stderr] 499 |         pub right: std::boxed::Box<AST>,
[INFO] [stderr]     |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:743:35
[INFO] [stderr]     |
[INFO] [stderr] 743 |         pub left: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:744:36
[INFO] [stderr]     |
[INFO] [stderr] 744 |         pub right: std::boxed::Box<AST>,
[INFO] [stderr]     |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:832:37
[INFO] [stderr]     |
[INFO] [stderr] 832 |         pub callee: std::boxed::Box<AST>,
[INFO] [stderr]     |                                     ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:833:39
[INFO] [stderr]     |
[INFO] [stderr] 833 |         pub args: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                       ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:885:37
[INFO] [stderr]     |
[INFO] [stderr] 885 |         MemExprIden(std::boxed::Box<AST>),
[INFO] [stderr]     |                                     ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:886:35
[INFO] [stderr]     |
[INFO] [stderr] 886 |         MemExprNs(std::boxed::Box<AST>),
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:887:33
[INFO] [stderr]     |
[INFO] [stderr] 887 |         MemExpr(std::boxed::Box<AST>),
[INFO] [stderr]     |                                 ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:888:38
[INFO] [stderr]     |
[INFO] [stderr] 888 |         CallExpr(Vec<std::boxed::Box<AST>>),
[INFO] [stderr]     |                                      ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:896:35
[INFO] [stderr]     |
[INFO] [stderr] 896 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:897:35
[INFO] [stderr]     |
[INFO] [stderr] 897 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:898:41
[INFO] [stderr]     |
[INFO] [stderr] 898 |         pub alt: Option<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                         ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:951:35
[INFO] [stderr]     |
[INFO] [stderr] 951 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:952:35
[INFO] [stderr]     |
[INFO] [stderr] 952 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:997:35
[INFO] [stderr]     |
[INFO] [stderr] 997 |         pub from: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:998:33
[INFO] [stderr]     |
[INFO] [stderr] 998 |         pub to: std::boxed::Box<AST>,
[INFO] [stderr]     |                                 ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:999:35
[INFO] [stderr]     |
[INFO] [stderr] 999 |         pub step: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1000:35
[INFO] [stderr]      |
[INFO] [stderr] 1000 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1078:35
[INFO] [stderr]      |
[INFO] [stderr] 1078 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1079:35
[INFO] [stderr]      |
[INFO] [stderr] 1079 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1206:42
[INFO] [stderr]      |
[INFO] [stderr] 1206 |         pub expr: Option<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                          ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1278:40
[INFO] [stderr]      |
[INFO] [stderr] 1278 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1335:36
[INFO] [stderr]      |
[INFO] [stderr] 1335 |         pub etype: std::boxed::Box<AST>,
[INFO] [stderr]      |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1336:40
[INFO] [stderr]      |
[INFO] [stderr] 1336 |         pub id: Option<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1337:40
[INFO] [stderr]      |
[INFO] [stderr] 1337 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1355:35
[INFO] [stderr]      |
[INFO] [stderr] 1355 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1375:35
[INFO] [stderr]      |
[INFO] [stderr] 1375 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1421:40
[INFO] [stderr]      |
[INFO] [stderr] 1421 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:78:149
[INFO] [stderr]    |
[INFO] [stderr] 78 |  fn __parse_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = match __parse_program_prologue ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement_program ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:639
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:653
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:667
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:1811
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:84:548
[INFO] [stderr]    |
[INFO] [stderr] 84 |  fn __parse_float_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < f64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<f64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "float literal" ) ; Failed } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:84:1313
[INFO] [stderr]    |
[INFO] [stderr] 84 |  fn __parse_float_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < f64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<f64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "float literal" ) ; Failed } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:94:343
[INFO] [stderr]    |
[INFO] [stderr] 94 |  fn __parse_id_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                       ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:94:357
[INFO] [stderr]    |
[INFO] [stderr] 94 |  fn __parse_id_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                     ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:343
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                       ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:357
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                     ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:383
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                               ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:120:145
[INFO] [stderr]     |
[INFO] [stderr] 120 |  fn __parse_value < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_float_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(FloatLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_int_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(IntLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_string_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(StrLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(Identifier, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_array_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_function_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } } } } } } } } } } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:122:150
[INFO] [stderr]     |
[INFO] [stderr] 122 |  fn __parse_array_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "]" ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ArrayExpr, ps, pe, exprs: vec![])  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "[" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , fexpr ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , lexpr ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:128:150
[INFO] [stderr]     |
[INFO] [stderr] 128 |  fn __parse_unary_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = { let str_start = __pos ; match { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "not" ) ; match __seq_res { Matched ( __pos , _ ) => { { __state . suppress_fail += 1 ; let __assert_res = match __parse_id_chars ( __input , __state , __pos ) { Matched ( pos , _ ) => Matched ( pos , ( ) ) , Failed => Failed , } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "-" ) } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , op ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_value ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , val ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:138:151
[INFO] [stderr]     |
[INFO] [stderr] 138 |  fn __parse_record_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "record" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_record_body_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:144:153
[INFO] [stderr]     |
[INFO] [stderr] 144 |  fn __parse_function_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "function" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , i ) => { Matched ( __pos , { i } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_function_arguments ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:161:144
[INFO] [stderr]     |
[INFO] [stderr] 161 |  fn __parse_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_assignmentexpr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "expression" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:163:154
[INFO] [stderr]     |
[INFO] [stderr] 163 |  fn __parse_assignmentexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_condexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Assign)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Adds)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Subs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Muls)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Divs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "%=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mods)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_condexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:163:395
[INFO] [stderr]     |
[INFO] [stderr] 163 |  fn __parse_assignmentexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_condexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Assign)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Adds)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Subs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Muls)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Divs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "%=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mods)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_condexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                                                                                                                                                                                                                                                                           ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:165:148
[INFO] [stderr]     |
[INFO] [stderr] 165 |  fn __parse_condexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , cond ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "?" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , then ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , alt ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(CondExpr, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:170:147
[INFO] [stderr]     |
[INFO] [stderr] 170 |  fn __parse_binexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_callexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseAnd)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "|" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseOr )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "xor" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseXor )  } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "and" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::And)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "or" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Or )  } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "==" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Eq )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "!=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Neq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Gt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Lt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Geq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Leq)  } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "of" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Of )  } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Add)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Sub)  } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mul)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Div)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "mod" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mod)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_callexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:170:388
[INFO] [stderr]     |
[INFO] [stderr] 170 |  fn __parse_binexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_callexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseAnd)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "|" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseOr )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "xor" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseXor )  } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "and" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::And)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "or" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Or )  } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "==" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Eq )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "!=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Neq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Gt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Lt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Geq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Leq)  } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "of" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Of )  } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Add)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Sub)  } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mul)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Div)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "mod" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mod)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_callexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                                                                                                                                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:172:148
[INFO] [stderr]     |
[INFO] [stderr] 172 |  fn __parse_callexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_memexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _left ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_callexpr_args ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_callexpr_arm ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , _right ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:173:28
[INFO] [stderr]     |
[INFO] [stderr] 173 |         let mut left : Box<ast::AST> = boxed!(CallExpr, ps, pe,
[INFO] [stderr]     |                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:211:157
[INFO] [stderr]     |
[INFO] [stderr] 211 |  fn __parse_callexpr_args < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , farg ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , larg ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                             ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:219:68
[INFO] [stderr]     |
[INFO] [stderr] 219 |             boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:221:68
[INFO] [stderr]     |
[INFO] [stderr] 221 |             boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:229:147
[INFO] [stderr]     |
[INFO] [stderr] 229 |  fn __parse_memexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_unary_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _left ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_memexpr_arm ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , __repeat_value ) } else { Failed } } ; match __seq_res { Matched ( __pos , _right ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:242:152
[INFO] [stderr]     |
[INFO] [stderr] 242 |  fn __parse_memexpr_arm < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < (std::boxed::Box<ast::AST>, bool /* is_expr */, bool /* is_namespace */) > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                        ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:243:65
[INFO] [stderr]     |
[INFO] [stderr] 243 |         (boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>,
[INFO] [stderr]     |                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:245:65
[INFO] [stderr]     |
[INFO] [stderr] 245 |         (boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>,
[INFO] [stderr]     |                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:251:164
[INFO] [stderr]     |
[INFO] [stderr] 251 |  fn __parse_statement_program_no_eos < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_block_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_if_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_while_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_for_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_for_in_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_function_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_try_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_raise_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_use_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_expr_stmt ( __input , __state , __pos ) } } } } } } } } } } } } } } } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:253:157
[INFO] [stderr]     |
[INFO] [stderr] 253 |  fn __parse_statement_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_program_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                             ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:255:156
[INFO] [stderr]     |
[INFO] [stderr] 255 |  fn __parse_statement_no_eos < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_statement_program_no_eos ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_return_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_continue_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_break_stmt ( __input , __state , __pos ) } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:257:149
[INFO] [stderr]     |
[INFO] [stderr] 257 |  fn __parse_statement < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:259:150
[INFO] [stderr]     |
[INFO] [stderr] 259 |  fn __parse_block_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "begin" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BlockStatement, ps, pe, stmts: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "begin" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BlockStatement, ps, pe, stmts: Vec::new())  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "block statement" ) ; Failed } } } } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:261:149
[INFO] [stderr]     |
[INFO] [stderr] 261 |  fn __parse_then_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "then" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { __state . suppress_fail += 1 ; let res = __parse_block_stmt ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "block or then <stmt>" ) ; Failed } } } } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:263:147
[INFO] [stderr]     |
[INFO] [stderr] 263 |  fn __parse_if_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "if" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = match { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "else" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , a ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(IfStatement, ps, pe, expr: e, then: s, alt: a)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:265:150
[INFO] [stderr]     |
[INFO] [stderr] 265 |  fn __parse_while_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "while" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(WhileStatement, ps, pe, expr: e, then: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:267:148
[INFO] [stderr]     |
[INFO] [stderr] 267 |  fn __parse_for_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "for" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , from ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "to" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  true  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = slice_eq ( __input , __state , __pos , "downto" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  false  } ) } Failed => Failed , } } } } ; match __seq_res { Matched ( __pos , dir ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , to ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "step" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , step ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:280:151
[INFO] [stderr]     |
[INFO] [stderr] 280 |  fn __parse_for_in_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "for" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "in" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expr ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:287:153
[INFO] [stderr]     |
[INFO] [stderr] 287 |  fn __parse_continue_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "continue" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ContinueStatement, ps, pe,)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:289:150
[INFO] [stderr]     |
[INFO] [stderr] 289 |  fn __parse_break_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "break" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BreakStatement, ps, pe,)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:291:148
[INFO] [stderr]     |
[INFO] [stderr] 291 |  fn __parse_try_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "try" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , stmts ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_case_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , cases ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(TryStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:300:150
[INFO] [stderr]     |
[INFO] [stderr] 300 |  fn __parse_raise_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "raise" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expr ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(RaiseStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:303:148
[INFO] [stderr]     |
[INFO] [stderr] 303 |  fn __parse_use_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "use" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_string_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , path ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(UseStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:318:153
[INFO] [stderr]     |
[INFO] [stderr] 318 |  fn __parse_function_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "function" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_function_arguments ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:327:151
[INFO] [stderr]     |
[INFO] [stderr] 327 |  fn __parse_return_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "return" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ReturnStatement, ps, pe, expr: e)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:329:156
[INFO] [stderr]     |
[INFO] [stderr] 329 |  fn __parse_record_body_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let __choice_res = __parse_function_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_expr_stmt ( __input , __state , __pos ) } } } } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:331:151
[INFO] [stderr]     |
[INFO] [stderr] 331 |  fn __parse_record_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "record" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_record_body_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:339:149
[INFO] [stderr]     |
[INFO] [stderr] 339 |  fn __parse_expr_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ExprStatement, ps, pe, expr: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:341:90
[INFO] [stderr]     |
[INFO] [stderr] 341 |  pub fn start < 'input > ( __input : & 'input str ) -> ParseResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_start ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) }
[INFO] [stderr]     |                                                                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::vmbindings::interned_string_map::InternedStringMap`
[INFO] [stderr]  --> src/hanayo/eval.rs:4:5
[INFO] [stderr]   |
[INFO] [stderr] 4 | use crate::vmbindings::interned_string_map::InternedStringMap;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> src/vmbindings/record.rs:19:34
[INFO] [stderr]    |
[INFO] [stderr] 19 |     pub native_field: Option<Box<Any>>,
[INFO] [stderr]    |                                  ^^^ help: use `dyn`: `dyn Any`
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:165:18
[INFO] [stderr]     |
[INFO] [stderr] 165 |                 0...0xff => {
[INFO] [stderr]     |                  ^^^ help: use `..=` for an inclusive range
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(ellipsis_inclusive_range_patterns)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:169:22
[INFO] [stderr]     |
[INFO] [stderr] 169 |                 0x100...0xffff => {
[INFO] [stderr]     |                      ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:173:24
[INFO] [stderr]     |
[INFO] [stderr] 173 |                 0x10000...0xffffffff => {
[INFO] [stderr]     |                        ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:211:40
[INFO] [stderr]     |
[INFO] [stderr] 211 |         pub exprs: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(bare_trait_objects)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:244:35
[INFO] [stderr]     |
[INFO] [stderr] 244 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:316:40
[INFO] [stderr]     |
[INFO] [stderr] 316 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:371:34
[INFO] [stderr]     |
[INFO] [stderr] 371 |         pub val: std::boxed::Box<AST>,
[INFO] [stderr]     |                                  ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:400:35
[INFO] [stderr]     |
[INFO] [stderr] 400 |         pub cond: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:401:35
[INFO] [stderr]     |
[INFO] [stderr] 401 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:402:34
[INFO] [stderr]     |
[INFO] [stderr] 402 |         pub alt: std::boxed::Box<AST>,
[INFO] [stderr]     |                                  ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:498:35
[INFO] [stderr]     |
[INFO] [stderr] 498 |         pub left: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:499:36
[INFO] [stderr]     |
[INFO] [stderr] 499 |         pub right: std::boxed::Box<AST>,
[INFO] [stderr]     |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:743:35
[INFO] [stderr]     |
[INFO] [stderr] 743 |         pub left: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:744:36
[INFO] [stderr]     |
[INFO] [stderr] 744 |         pub right: std::boxed::Box<AST>,
[INFO] [stderr]     |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:832:37
[INFO] [stderr]     |
[INFO] [stderr] 832 |         pub callee: std::boxed::Box<AST>,
[INFO] [stderr]     |                                     ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:833:39
[INFO] [stderr]     |
[INFO] [stderr] 833 |         pub args: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                       ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:885:37
[INFO] [stderr]     |
[INFO] [stderr] 885 |         MemExprIden(std::boxed::Box<AST>),
[INFO] [stderr]     |                                     ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:886:35
[INFO] [stderr]     |
[INFO] [stderr] 886 |         MemExprNs(std::boxed::Box<AST>),
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:887:33
[INFO] [stderr]     |
[INFO] [stderr] 887 |         MemExpr(std::boxed::Box<AST>),
[INFO] [stderr]     |                                 ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:888:38
[INFO] [stderr]     |
[INFO] [stderr] 888 |         CallExpr(Vec<std::boxed::Box<AST>>),
[INFO] [stderr]     |                                      ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:896:35
[INFO] [stderr]     |
[INFO] [stderr] 896 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:897:35
[INFO] [stderr]     |
[INFO] [stderr] 897 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:898:41
[INFO] [stderr]     |
[INFO] [stderr] 898 |         pub alt: Option<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                         ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:951:35
[INFO] [stderr]     |
[INFO] [stderr] 951 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:952:35
[INFO] [stderr]     |
[INFO] [stderr] 952 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:997:35
[INFO] [stderr]     |
[INFO] [stderr] 997 |         pub from: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:998:33
[INFO] [stderr]     |
[INFO] [stderr] 998 |         pub to: std::boxed::Box<AST>,
[INFO] [stderr]     |                                 ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:999:35
[INFO] [stderr]     |
[INFO] [stderr] 999 |         pub step: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1000:35
[INFO] [stderr]      |
[INFO] [stderr] 1000 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1078:35
[INFO] [stderr]      |
[INFO] [stderr] 1078 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1079:35
[INFO] [stderr]      |
[INFO] [stderr] 1079 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1206:42
[INFO] [stderr]      |
[INFO] [stderr] 1206 |         pub expr: Option<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                          ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1278:40
[INFO] [stderr]      |
[INFO] [stderr] 1278 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1335:36
[INFO] [stderr]      |
[INFO] [stderr] 1335 |         pub etype: std::boxed::Box<AST>,
[INFO] [stderr]      |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1336:40
[INFO] [stderr]      |
[INFO] [stderr] 1336 |         pub id: Option<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1337:40
[INFO] [stderr]      |
[INFO] [stderr] 1337 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1355:35
[INFO] [stderr]      |
[INFO] [stderr] 1355 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1375:35
[INFO] [stderr]      |
[INFO] [stderr] 1375 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1421:40
[INFO] [stderr]      |
[INFO] [stderr] 1421 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:78:149
[INFO] [stderr]    |
[INFO] [stderr] 78 |  fn __parse_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = match __parse_program_prologue ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement_program ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:639
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:653
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:667
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:1811
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:84:548
[INFO] [stderr]    |
[INFO] [stderr] 84 |  fn __parse_float_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < f64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<f64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "float literal" ) ; Failed } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:84:1313
[INFO] [stderr]    |
[INFO] [stderr] 84 |  fn __parse_float_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < f64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<f64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "float literal" ) ; Failed } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:94:343
[INFO] [stderr]    |
[INFO] [stderr] 94 |  fn __parse_id_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                       ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:94:357
[INFO] [stderr]    |
[INFO] [stderr] 94 |  fn __parse_id_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                     ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:343
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                       ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:357
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                     ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:383
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                               ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:120:145
[INFO] [stderr]     |
[INFO] [stderr] 120 |  fn __parse_value < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_float_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(FloatLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_int_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(IntLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_string_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(StrLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(Identifier, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_array_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_function_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } } } } } } } } } } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:122:150
[INFO] [stderr]     |
[INFO] [stderr] 122 |  fn __parse_array_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "]" ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ArrayExpr, ps, pe, exprs: vec![])  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "[" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , fexpr ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , lexpr ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:128:150
[INFO] [stderr]     |
[INFO] [stderr] 128 |  fn __parse_unary_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = { let str_start = __pos ; match { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "not" ) ; match __seq_res { Matched ( __pos , _ ) => { { __state . suppress_fail += 1 ; let __assert_res = match __parse_id_chars ( __input , __state , __pos ) { Matched ( pos , _ ) => Matched ( pos , ( ) ) , Failed => Failed , } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "-" ) } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , op ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_value ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , val ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:138:151
[INFO] [stderr]     |
[INFO] [stderr] 138 |  fn __parse_record_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "record" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_record_body_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:144:153
[INFO] [stderr]     |
[INFO] [stderr] 144 |  fn __parse_function_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "function" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , i ) => { Matched ( __pos , { i } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_function_arguments ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:161:144
[INFO] [stderr]     |
[INFO] [stderr] 161 |  fn __parse_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_assignmentexpr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "expression" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:163:154
[INFO] [stderr]     |
[INFO] [stderr] 163 |  fn __parse_assignmentexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_condexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Assign)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Adds)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Subs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Muls)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Divs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "%=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mods)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_condexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:163:395
[INFO] [stderr]     |
[INFO] [stderr] 163 |  fn __parse_assignmentexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_condexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Assign)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Adds)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Subs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Muls)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Divs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "%=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mods)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_condexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                                                                                                                                                                                                                                                                           ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:165:148
[INFO] [stderr]     |
[INFO] [stderr] 165 |  fn __parse_condexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , cond ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "?" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , then ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , alt ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(CondExpr, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:170:147
[INFO] [stderr]     |
[INFO] [stderr] 170 |  fn __parse_binexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_callexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseAnd)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "|" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseOr )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "xor" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseXor )  } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "and" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::And)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "or" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Or )  } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "==" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Eq )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "!=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Neq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Gt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Lt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Geq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Leq)  } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "of" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Of )  } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Add)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Sub)  } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mul)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Div)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "mod" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mod)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_callexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:170:388
[INFO] [stderr]     |
[INFO] [stderr] 170 |  fn __parse_binexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_callexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseAnd)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "|" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseOr )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "xor" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseXor )  } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "and" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::And)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "or" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Or )  } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "==" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Eq )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "!=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Neq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Gt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Lt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Geq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Leq)  } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "of" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Of )  } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Add)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Sub)  } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mul)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Div)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "mod" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mod)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_callexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                                                                                                                                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:172:148
[INFO] [stderr]     |
[INFO] [stderr] 172 |  fn __parse_callexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_memexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _left ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_callexpr_args ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_callexpr_arm ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , _right ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:173:28
[INFO] [stderr]     |
[INFO] [stderr] 173 |         let mut left : Box<ast::AST> = boxed!(CallExpr, ps, pe,
[INFO] [stderr]     |                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:211:157
[INFO] [stderr]     |
[INFO] [stderr] 211 |  fn __parse_callexpr_args < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , farg ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , larg ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                             ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:219:68
[INFO] [stderr]     |
[INFO] [stderr] 219 |             boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:221:68
[INFO] [stderr]     |
[INFO] [stderr] 221 |             boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:229:147
[INFO] [stderr]     |
[INFO] [stderr] 229 |  fn __parse_memexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_unary_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _left ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_memexpr_arm ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , __repeat_value ) } else { Failed } } ; match __seq_res { Matched ( __pos , _right ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:242:152
[INFO] [stderr]     |
[INFO] [stderr] 242 |  fn __parse_memexpr_arm < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < (std::boxed::Box<ast::AST>, bool /* is_expr */, bool /* is_namespace */) > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                        ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:243:65
[INFO] [stderr]     |
[INFO] [stderr] 243 |         (boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>,
[INFO] [stderr]     |                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:245:65
[INFO] [stderr]     |
[INFO] [stderr] 245 |         (boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>,
[INFO] [stderr]     |                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:251:164
[INFO] [stderr]     |
[INFO] [stderr] 251 |  fn __parse_statement_program_no_eos < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_block_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_if_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_while_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_for_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_for_in_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_function_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_try_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_raise_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_use_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_expr_stmt ( __input , __state , __pos ) } } } } } } } } } } } } } } } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:253:157
[INFO] [stderr]     |
[INFO] [stderr] 253 |  fn __parse_statement_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_program_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                             ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:255:156
[INFO] [stderr]     |
[INFO] [stderr] 255 |  fn __parse_statement_no_eos < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_statement_program_no_eos ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_return_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_continue_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_break_stmt ( __input , __state , __pos ) } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:257:149
[INFO] [stderr]     |
[INFO] [stderr] 257 |  fn __parse_statement < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:259:150
[INFO] [stderr]     |
[INFO] [stderr] 259 |  fn __parse_block_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "begin" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BlockStatement, ps, pe, stmts: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "begin" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BlockStatement, ps, pe, stmts: Vec::new())  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "block statement" ) ; Failed } } } } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:261:149
[INFO] [stderr]     |
[INFO] [stderr] 261 |  fn __parse_then_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "then" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { __state . suppress_fail += 1 ; let res = __parse_block_stmt ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "block or then <stmt>" ) ; Failed } } } } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:263:147
[INFO] [stderr]     |
[INFO] [stderr] 263 |  fn __parse_if_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "if" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = match { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "else" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , a ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(IfStatement, ps, pe, expr: e, then: s, alt: a)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:265:150
[INFO] [stderr]     |
[INFO] [stderr] 265 |  fn __parse_while_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "while" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(WhileStatement, ps, pe, expr: e, then: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:267:148
[INFO] [stderr]     |
[INFO] [stderr] 267 |  fn __parse_for_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "for" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , from ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "to" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  true  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = slice_eq ( __input , __state , __pos , "downto" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  false  } ) } Failed => Failed , } } } } ; match __seq_res { Matched ( __pos , dir ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , to ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "step" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , step ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:280:151
[INFO] [stderr]     |
[INFO] [stderr] 280 |  fn __parse_for_in_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "for" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "in" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expr ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:287:153
[INFO] [stderr]     |
[INFO] [stderr] 287 |  fn __parse_continue_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "continue" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ContinueStatement, ps, pe,)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:289:150
[INFO] [stderr]     |
[INFO] [stderr] 289 |  fn __parse_break_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "break" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BreakStatement, ps, pe,)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:291:148
[INFO] [stderr]     |
[INFO] [stderr] 291 |  fn __parse_try_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "try" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , stmts ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_case_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , cases ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(TryStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:300:150
[INFO] [stderr]     |
[INFO] [stderr] 300 |  fn __parse_raise_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "raise" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expr ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(RaiseStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:303:148
[INFO] [stderr]     |
[INFO] [stderr] 303 |  fn __parse_use_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "use" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_string_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , path ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(UseStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:318:153
[INFO] [stderr]     |
[INFO] [stderr] 318 |  fn __parse_function_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "function" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_function_arguments ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:327:151
[INFO] [stderr]     |
[INFO] [stderr] 327 |  fn __parse_return_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "return" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ReturnStatement, ps, pe, expr: e)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:329:156
[INFO] [stderr]     |
[INFO] [stderr] 329 |  fn __parse_record_body_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let __choice_res = __parse_function_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_expr_stmt ( __input , __state , __pos ) } } } } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:331:151
[INFO] [stderr]     |
[INFO] [stderr] 331 |  fn __parse_record_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "record" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_record_body_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:339:149
[INFO] [stderr]     |
[INFO] [stderr] 339 |  fn __parse_expr_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ExprStatement, ps, pe, expr: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:341:90
[INFO] [stderr]     |
[INFO] [stderr] 341 |  pub fn start < 'input > ( __input : & 'input str ) -> ParseResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_start ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) }
[INFO] [stderr]     |                                                                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::vmbindings::interned_string_map::InternedStringMap`
[INFO] [stderr]  --> src/hanayo/eval.rs:4:5
[INFO] [stderr]   |
[INFO] [stderr] 4 | use crate::vmbindings::interned_string_map::InternedStringMap;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> src/vmbindings/record.rs:19:34
[INFO] [stderr]    |
[INFO] [stderr] 19 |     pub native_field: Option<Box<Any>>,
[INFO] [stderr]    |                                  ^^^ help: use `dyn`: `dyn Any`
[INFO] [stderr] 
[INFO] [stderr] warning: field is never read: `pointer`
[INFO] [stderr]   --> src/vmbindings/vm.rs:32:5
[INFO] [stderr]    |
[INFO] [stderr] 32 |     pointer: std::num::NonZeroUsize,
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(dead_code)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> src/hanayo/cmd.rs:181:17
[INFO] [stderr]     |
[INFO] [stderr] 181 |                 p.stdin.as_mut().unwrap().write_all(s.as_ref().as_bytes());
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(unused_must_use)]` on by default
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/file.rs:72:5
[INFO] [stderr]    |
[INFO] [stderr] 72 |     file.read_to_string(&mut s);
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/file.rs:82:5
[INFO] [stderr]    |
[INFO] [stderr] 82 |     file.read_exact(&mut bytes);
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/proc.rs:15:5
[INFO] [stderr]    |
[INFO] [stderr] 15 | /     p.stdin
[INFO] [stderr] 16 | |         .as_mut()
[INFO] [stderr] 17 | |         .unwrap()
[INFO] [stderr] 18 | |         .write_all(input.as_ref().as_bytes());
[INFO] [stderr]    | |______________________________________________^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: field is never read: `pointer`
[INFO] [stderr]   --> src/vmbindings/vm.rs:32:5
[INFO] [stderr]    |
[INFO] [stderr] 32 |     pointer: std::num::NonZeroUsize,
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(dead_code)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> src/hanayo/cmd.rs:181:17
[INFO] [stderr]     |
[INFO] [stderr] 181 |                 p.stdin.as_mut().unwrap().write_all(s.as_ref().as_bytes());
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(unused_must_use)]` on by default
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/file.rs:72:5
[INFO] [stderr]    |
[INFO] [stderr] 72 |     file.read_to_string(&mut s);
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/file.rs:82:5
[INFO] [stderr]    |
[INFO] [stderr] 82 |     file.read_exact(&mut bytes);
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/proc.rs:15:5
[INFO] [stderr]    |
[INFO] [stderr] 15 | /     p.stdin
[INFO] [stderr] 16 | |         .as_mut()
[INFO] [stderr] 17 | |         .unwrap()
[INFO] [stderr] 18 | |         .write_all(input.as_ref().as_bytes());
[INFO] [stderr]    | |______________________________________________^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> tests/parser.rs:23:42
[INFO] [stderr]    |
[INFO] [stderr] 23 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("a");
[INFO] [stderr]    |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(bare_trait_objects)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> tests/parser.rs:31:42
[INFO] [stderr]    |
[INFO] [stderr] 31 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("'a'");
[INFO] [stderr]    |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> tests/parser.rs:39:42
[INFO] [stderr]    |
[INFO] [stderr] 39 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("'\\n'");
[INFO] [stderr]    |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> tests/parser.rs:47:42
[INFO] [stderr]    |
[INFO] [stderr] 47 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("125");
[INFO] [stderr]    |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> tests/parser.rs:55:42
[INFO] [stderr]    |
[INFO] [stderr] 55 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("0xf");
[INFO] [stderr]    |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> tests/parser.rs:63:42
[INFO] [stderr]    |
[INFO] [stderr] 63 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("12.6");
[INFO] [stderr]    |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> tests/parser.rs:73:42
[INFO] [stderr]    |
[INFO] [stderr] 73 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("// Test");
[INFO] [stderr]    |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> tests/parser.rs:78:42
[INFO] [stderr]    |
[INFO] [stderr] 78 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]    |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> tests/parser.rs:90:42
[INFO] [stderr]    |
[INFO] [stderr] 90 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("a.b");
[INFO] [stderr]    |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:100:42
[INFO] [stderr]     |
[INFO] [stderr] 100 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("a['b']");
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:112:42
[INFO] [stderr]     |
[INFO] [stderr] 112 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("a(1,2)");
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:126:42
[INFO] [stderr]     |
[INFO] [stderr] 126 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!("a + b");
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:139:42
[INFO] [stderr]     |
[INFO] [stderr] 139 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:171:42
[INFO] [stderr]     |
[INFO] [stderr] 171 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:190:42
[INFO] [stderr]     |
[INFO] [stderr] 190 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:213:42
[INFO] [stderr]     |
[INFO] [stderr] 213 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:234:42
[INFO] [stderr]     |
[INFO] [stderr] 234 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:248:42
[INFO] [stderr]     |
[INFO] [stderr] 248 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:265:42
[INFO] [stderr]     |
[INFO] [stderr] 265 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:282:42
[INFO] [stderr]     |
[INFO] [stderr] 282 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> tests/parser.rs:299:42
[INFO] [stderr]     |
[INFO] [stderr] 299 |         let progast: Vec<std::boxed::Box<ast::AST>> = parse_ast_statement!(
[INFO] [stderr]     |                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `haru::vmbindings::vmerror::VmError`
[INFO] [stderr]  --> tests/hanayo.rs:9:5
[INFO] [stderr]   |
[INFO] [stderr] 9 | use haru::vmbindings::vmerror::VmError;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/vm.rs:116:9
[INFO] [stderr]     |
[INFO] [stderr] 116 |         c.cpushs("Test");
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(unused_must_use)]` on by default
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/vm.rs:131:9
[INFO] [stderr]     |
[INFO] [stderr] 131 |         c.cpushs("Test");
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/vm.rs:133:9
[INFO] [stderr]     |
[INFO] [stderr] 133 |         c.cpushs("Test");
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/vm.rs:149:9
[INFO] [stderr]     |
[INFO] [stderr] 149 |         c.cpushs("Test");
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/vm.rs:171:9
[INFO] [stderr]     |
[INFO] [stderr] 171 |         c.cpushs("abc");
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/vm.rs:174:9
[INFO] [stderr]     |
[INFO] [stderr] 174 |         c.cpushs("abc");
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:165:18
[INFO] [stderr]     |
[INFO] [stderr] 165 |                 0...0xff => {
[INFO] [stderr]     |                  ^^^ help: use `..=` for an inclusive range
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(ellipsis_inclusive_range_patterns)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:169:22
[INFO] [stderr]     |
[INFO] [stderr] 169 |                 0x100...0xffff => {
[INFO] [stderr]     |                      ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:173:24
[INFO] [stderr]     |
[INFO] [stderr] 173 |                 0x10000...0xffffffff => {
[INFO] [stderr]     |                        ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:211:40
[INFO] [stderr]     |
[INFO] [stderr] 211 |         pub exprs: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(bare_trait_objects)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:244:35
[INFO] [stderr]     |
[INFO] [stderr] 244 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:316:40
[INFO] [stderr]     |
[INFO] [stderr] 316 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:371:34
[INFO] [stderr]     |
[INFO] [stderr] 371 |         pub val: std::boxed::Box<AST>,
[INFO] [stderr]     |                                  ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:400:35
[INFO] [stderr]     |
[INFO] [stderr] 400 |         pub cond: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:401:35
[INFO] [stderr]     |
[INFO] [stderr] 401 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:402:34
[INFO] [stderr]     |
[INFO] [stderr] 402 |         pub alt: std::boxed::Box<AST>,
[INFO] [stderr]     |                                  ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:498:35
[INFO] [stderr]     |
[INFO] [stderr] 498 |         pub left: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:499:36
[INFO] [stderr]     |
[INFO] [stderr] 499 |         pub right: std::boxed::Box<AST>,
[INFO] [stderr]     |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:743:35
[INFO] [stderr]     |
[INFO] [stderr] 743 |         pub left: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:744:36
[INFO] [stderr]     |
[INFO] [stderr] 744 |         pub right: std::boxed::Box<AST>,
[INFO] [stderr]     |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:832:37
[INFO] [stderr]     |
[INFO] [stderr] 832 |         pub callee: std::boxed::Box<AST>,
[INFO] [stderr]     |                                     ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:833:39
[INFO] [stderr]     |
[INFO] [stderr] 833 |         pub args: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                       ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:885:37
[INFO] [stderr]     |
[INFO] [stderr] 885 |         MemExprIden(std::boxed::Box<AST>),
[INFO] [stderr]     |                                     ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:886:35
[INFO] [stderr]     |
[INFO] [stderr] 886 |         MemExprNs(std::boxed::Box<AST>),
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:887:33
[INFO] [stderr]     |
[INFO] [stderr] 887 |         MemExpr(std::boxed::Box<AST>),
[INFO] [stderr]     |                                 ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:888:38
[INFO] [stderr]     |
[INFO] [stderr] 888 |         CallExpr(Vec<std::boxed::Box<AST>>),
[INFO] [stderr]     |                                      ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:896:35
[INFO] [stderr]     |
[INFO] [stderr] 896 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:897:35
[INFO] [stderr]     |
[INFO] [stderr] 897 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:898:41
[INFO] [stderr]     |
[INFO] [stderr] 898 |         pub alt: Option<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                         ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:951:35
[INFO] [stderr]     |
[INFO] [stderr] 951 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:952:35
[INFO] [stderr]     |
[INFO] [stderr] 952 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:997:35
[INFO] [stderr]     |
[INFO] [stderr] 997 |         pub from: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:998:33
[INFO] [stderr]     |
[INFO] [stderr] 998 |         pub to: std::boxed::Box<AST>,
[INFO] [stderr]     |                                 ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:999:35
[INFO] [stderr]     |
[INFO] [stderr] 999 |         pub step: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1000:35
[INFO] [stderr]      |
[INFO] [stderr] 1000 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1078:35
[INFO] [stderr]      |
[INFO] [stderr] 1078 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1079:35
[INFO] [stderr]      |
[INFO] [stderr] 1079 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1206:42
[INFO] [stderr]      |
[INFO] [stderr] 1206 |         pub expr: Option<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                          ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1278:40
[INFO] [stderr]      |
[INFO] [stderr] 1278 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1335:36
[INFO] [stderr]      |
[INFO] [stderr] 1335 |         pub etype: std::boxed::Box<AST>,
[INFO] [stderr]      |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1336:40
[INFO] [stderr]      |
[INFO] [stderr] 1336 |         pub id: Option<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1337:40
[INFO] [stderr]      |
[INFO] [stderr] 1337 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1355:35
[INFO] [stderr]      |
[INFO] [stderr] 1355 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1375:35
[INFO] [stderr]      |
[INFO] [stderr] 1375 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1421:40
[INFO] [stderr]      |
[INFO] [stderr] 1421 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:78:149
[INFO] [stderr]    |
[INFO] [stderr] 78 |  fn __parse_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = match __parse_program_prologue ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement_program ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:639
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:653
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:667
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:1811
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:84:548
[INFO] [stderr]    |
[INFO] [stderr] 84 |  fn __parse_float_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < f64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<f64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "float literal" ) ; Failed } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:84:1313
[INFO] [stderr]    |
[INFO] [stderr] 84 |  fn __parse_float_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < f64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<f64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "float literal" ) ; Failed } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:94:343
[INFO] [stderr]    |
[INFO] [stderr] 94 |  fn __parse_id_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                       ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:94:357
[INFO] [stderr]    |
[INFO] [stderr] 94 |  fn __parse_id_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                     ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:343
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                       ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:357
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                     ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:383
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                               ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:120:145
[INFO] [stderr]     |
[INFO] [stderr] 120 |  fn __parse_value < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_float_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(FloatLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_int_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(IntLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_string_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(StrLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(Identifier, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_array_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_function_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } } } } } } } } } } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:122:150
[INFO] [stderr]     |
[INFO] [stderr] 122 |  fn __parse_array_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "]" ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ArrayExpr, ps, pe, exprs: vec![])  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "[" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , fexpr ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , lexpr ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:128:150
[INFO] [stderr]     |
[INFO] [stderr] 128 |  fn __parse_unary_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = { let str_start = __pos ; match { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "not" ) ; match __seq_res { Matched ( __pos , _ ) => { { __state . suppress_fail += 1 ; let __assert_res = match __parse_id_chars ( __input , __state , __pos ) { Matched ( pos , _ ) => Matched ( pos , ( ) ) , Failed => Failed , } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "-" ) } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , op ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_value ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , val ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:138:151
[INFO] [stderr]     |
[INFO] [stderr] 138 |  fn __parse_record_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "record" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_record_body_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:144:153
[INFO] [stderr]     |
[INFO] [stderr] 144 |  fn __parse_function_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "function" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , i ) => { Matched ( __pos , { i } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_function_arguments ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:161:144
[INFO] [stderr]     |
[INFO] [stderr] 161 |  fn __parse_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_assignmentexpr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "expression" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:163:154
[INFO] [stderr]     |
[INFO] [stderr] 163 |  fn __parse_assignmentexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_condexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Assign)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Adds)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Subs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Muls)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Divs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "%=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mods)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_condexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:163:395
[INFO] [stderr]     |
[INFO] [stderr] 163 |  fn __parse_assignmentexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_condexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Assign)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Adds)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Subs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Muls)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Divs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "%=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mods)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_condexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                                                                                                                                                                                                                                                                           ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:165:148
[INFO] [stderr]     |
[INFO] [stderr] 165 |  fn __parse_condexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , cond ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "?" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , then ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , alt ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(CondExpr, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:170:147
[INFO] [stderr]     |
[INFO] [stderr] 170 |  fn __parse_binexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_callexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseAnd)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "|" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseOr )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "xor" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseXor )  } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "and" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::And)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "or" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Or )  } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "==" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Eq )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "!=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Neq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Gt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Lt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Geq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Leq)  } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "of" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Of )  } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Add)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Sub)  } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mul)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Div)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "mod" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mod)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_callexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:170:388
[INFO] [stderr]     |
[INFO] [stderr] 170 |  fn __parse_binexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_callexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseAnd)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "|" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseOr )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "xor" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseXor )  } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "and" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::And)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "or" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Or )  } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "==" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Eq )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "!=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Neq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Gt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Lt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Geq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Leq)  } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "of" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Of )  } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Add)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Sub)  } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mul)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Div)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "mod" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mod)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_callexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                                                                                                                                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:172:148
[INFO] [stderr]     |
[INFO] [stderr] 172 |  fn __parse_callexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_memexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _left ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_callexpr_args ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_callexpr_arm ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , _right ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:173:28
[INFO] [stderr]     |
[INFO] [stderr] 173 |         let mut left : Box<ast::AST> = boxed!(CallExpr, ps, pe,
[INFO] [stderr]     |                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:211:157
[INFO] [stderr]     |
[INFO] [stderr] 211 |  fn __parse_callexpr_args < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , farg ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , larg ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                             ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:219:68
[INFO] [stderr]     |
[INFO] [stderr] 219 |             boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:221:68
[INFO] [stderr]     |
[INFO] [stderr] 221 |             boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:229:147
[INFO] [stderr]     |
[INFO] [stderr] 229 |  fn __parse_memexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_unary_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _left ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_memexpr_arm ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , __repeat_value ) } else { Failed } } ; match __seq_res { Matched ( __pos , _right ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:242:152
[INFO] [stderr]     |
[INFO] [stderr] 242 |  fn __parse_memexpr_arm < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < (std::boxed::Box<ast::AST>, bool /* is_expr */, bool /* is_namespace */) > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                        ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:243:65
[INFO] [stderr]     |
[INFO] [stderr] 243 |         (boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>,
[INFO] [stderr]     |                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:245:65
[INFO] [stderr]     |
[INFO] [stderr] 245 |         (boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>,
[INFO] [stderr]     |                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:251:164
[INFO] [stderr]     |
[INFO] [stderr] 251 |  fn __parse_statement_program_no_eos < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_block_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_if_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_while_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_for_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_for_in_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_function_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_try_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_raise_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_use_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_expr_stmt ( __input , __state , __pos ) } } } } } } } } } } } } } } } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:253:157
[INFO] [stderr]     |
[INFO] [stderr] 253 |  fn __parse_statement_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_program_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                             ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:255:156
[INFO] [stderr]     |
[INFO] [stderr] 255 |  fn __parse_statement_no_eos < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_statement_program_no_eos ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_return_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_continue_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_break_stmt ( __input , __state , __pos ) } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:257:149
[INFO] [stderr]     |
[INFO] [stderr] 257 |  fn __parse_statement < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:259:150
[INFO] [stderr]     |
[INFO] [stderr] 259 |  fn __parse_block_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "begin" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BlockStatement, ps, pe, stmts: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "begin" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BlockStatement, ps, pe, stmts: Vec::new())  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "block statement" ) ; Failed } } } } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:261:149
[INFO] [stderr]     |
[INFO] [stderr] 261 |  fn __parse_then_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "then" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { __state . suppress_fail += 1 ; let res = __parse_block_stmt ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "block or then <stmt>" ) ; Failed } } } } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:263:147
[INFO] [stderr]     |
[INFO] [stderr] 263 |  fn __parse_if_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "if" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = match { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "else" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , a ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(IfStatement, ps, pe, expr: e, then: s, alt: a)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:265:150
[INFO] [stderr]     |
[INFO] [stderr] 265 |  fn __parse_while_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "while" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(WhileStatement, ps, pe, expr: e, then: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:267:148
[INFO] [stderr]     |
[INFO] [stderr] 267 |  fn __parse_for_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "for" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , from ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "to" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  true  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = slice_eq ( __input , __state , __pos , "downto" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  false  } ) } Failed => Failed , } } } } ; match __seq_res { Matched ( __pos , dir ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , to ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "step" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , step ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:280:151
[INFO] [stderr]     |
[INFO] [stderr] 280 |  fn __parse_for_in_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "for" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "in" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expr ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:287:153
[INFO] [stderr]     |
[INFO] [stderr] 287 |  fn __parse_continue_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "continue" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ContinueStatement, ps, pe,)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:289:150
[INFO] [stderr]     |
[INFO] [stderr] 289 |  fn __parse_break_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "break" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BreakStatement, ps, pe,)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:291:148
[INFO] [stderr]     |
[INFO] [stderr] 291 |  fn __parse_try_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "try" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , stmts ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_case_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , cases ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(TryStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:300:150
[INFO] [stderr]     |
[INFO] [stderr] 300 |  fn __parse_raise_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "raise" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expr ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(RaiseStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:303:148
[INFO] [stderr]     |
[INFO] [stderr] 303 |  fn __parse_use_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "use" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_string_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , path ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(UseStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:318:153
[INFO] [stderr]     |
[INFO] [stderr] 318 |  fn __parse_function_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "function" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_function_arguments ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:327:151
[INFO] [stderr]     |
[INFO] [stderr] 327 |  fn __parse_return_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "return" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ReturnStatement, ps, pe, expr: e)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:329:156
[INFO] [stderr]     |
[INFO] [stderr] 329 |  fn __parse_record_body_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let __choice_res = __parse_function_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_expr_stmt ( __input , __state , __pos ) } } } } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:331:151
[INFO] [stderr]     |
[INFO] [stderr] 331 |  fn __parse_record_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "record" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_record_body_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:339:149
[INFO] [stderr]     |
[INFO] [stderr] 339 |  fn __parse_expr_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ExprStatement, ps, pe, expr: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:341:90
[INFO] [stderr]     |
[INFO] [stderr] 341 |  pub fn start < 'input > ( __input : & 'input str ) -> ParseResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_start ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) }
[INFO] [stderr]     |                                                                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> src/vmbindings/record.rs:19:34
[INFO] [stderr]    |
[INFO] [stderr] 19 |     pub native_field: Option<Box<Any>>,
[INFO] [stderr]    |                                  ^^^ help: use `dyn`: `dyn Any`
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::vmbindings::interned_string_map::InternedStringMap`
[INFO] [stderr]  --> src/hanayo/eval.rs:4:5
[INFO] [stderr]   |
[INFO] [stderr] 4 | use crate::vmbindings::interned_string_map::InternedStringMap;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:165:18
[INFO] [stderr]     |
[INFO] [stderr] 165 |                 0...0xff => {
[INFO] [stderr]     |                  ^^^ help: use `..=` for an inclusive range
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(ellipsis_inclusive_range_patterns)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:169:22
[INFO] [stderr]     |
[INFO] [stderr] 169 |                 0x100...0xffff => {
[INFO] [stderr]     |                      ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]    --> src/ast.rs:173:24
[INFO] [stderr]     |
[INFO] [stderr] 173 |                 0x10000...0xffffffff => {
[INFO] [stderr]     |                        ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:211:40
[INFO] [stderr]     |
[INFO] [stderr] 211 |         pub exprs: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(bare_trait_objects)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:244:35
[INFO] [stderr]     |
[INFO] [stderr] 244 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:316:40
[INFO] [stderr]     |
[INFO] [stderr] 316 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:371:34
[INFO] [stderr]     |
[INFO] [stderr] 371 |         pub val: std::boxed::Box<AST>,
[INFO] [stderr]     |                                  ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:400:35
[INFO] [stderr]     |
[INFO] [stderr] 400 |         pub cond: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:401:35
[INFO] [stderr]     |
[INFO] [stderr] 401 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:402:34
[INFO] [stderr]     |
[INFO] [stderr] 402 |         pub alt: std::boxed::Box<AST>,
[INFO] [stderr]     |                                  ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:498:35
[INFO] [stderr]     |
[INFO] [stderr] 498 |         pub left: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:499:36
[INFO] [stderr]     |
[INFO] [stderr] 499 |         pub right: std::boxed::Box<AST>,
[INFO] [stderr]     |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:743:35
[INFO] [stderr]     |
[INFO] [stderr] 743 |         pub left: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:744:36
[INFO] [stderr]     |
[INFO] [stderr] 744 |         pub right: std::boxed::Box<AST>,
[INFO] [stderr]     |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:832:37
[INFO] [stderr]     |
[INFO] [stderr] 832 |         pub callee: std::boxed::Box<AST>,
[INFO] [stderr]     |                                     ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:833:39
[INFO] [stderr]     |
[INFO] [stderr] 833 |         pub args: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                       ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:885:37
[INFO] [stderr]     |
[INFO] [stderr] 885 |         MemExprIden(std::boxed::Box<AST>),
[INFO] [stderr]     |                                     ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:886:35
[INFO] [stderr]     |
[INFO] [stderr] 886 |         MemExprNs(std::boxed::Box<AST>),
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:887:33
[INFO] [stderr]     |
[INFO] [stderr] 887 |         MemExpr(std::boxed::Box<AST>),
[INFO] [stderr]     |                                 ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:888:38
[INFO] [stderr]     |
[INFO] [stderr] 888 |         CallExpr(Vec<std::boxed::Box<AST>>),
[INFO] [stderr]     |                                      ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:896:35
[INFO] [stderr]     |
[INFO] [stderr] 896 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:897:35
[INFO] [stderr]     |
[INFO] [stderr] 897 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:898:41
[INFO] [stderr]     |
[INFO] [stderr] 898 |         pub alt: Option<std::boxed::Box<AST>>,
[INFO] [stderr]     |                                         ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:951:35
[INFO] [stderr]     |
[INFO] [stderr] 951 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:952:35
[INFO] [stderr]     |
[INFO] [stderr] 952 |         pub then: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:997:35
[INFO] [stderr]     |
[INFO] [stderr] 997 |         pub from: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:998:33
[INFO] [stderr]     |
[INFO] [stderr] 998 |         pub to: std::boxed::Box<AST>,
[INFO] [stderr]     |                                 ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> src/ast.rs:999:35
[INFO] [stderr]     |
[INFO] [stderr] 999 |         pub step: std::boxed::Box<AST>,
[INFO] [stderr]     |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1000:35
[INFO] [stderr]      |
[INFO] [stderr] 1000 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1078:35
[INFO] [stderr]      |
[INFO] [stderr] 1078 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1079:35
[INFO] [stderr]      |
[INFO] [stderr] 1079 |         pub stmt: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1206:42
[INFO] [stderr]      |
[INFO] [stderr] 1206 |         pub expr: Option<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                          ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1278:40
[INFO] [stderr]      |
[INFO] [stderr] 1278 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1335:36
[INFO] [stderr]      |
[INFO] [stderr] 1335 |         pub etype: std::boxed::Box<AST>,
[INFO] [stderr]      |                                    ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1336:40
[INFO] [stderr]      |
[INFO] [stderr] 1336 |         pub id: Option<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1337:40
[INFO] [stderr]      |
[INFO] [stderr] 1337 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1355:35
[INFO] [stderr]      |
[INFO] [stderr] 1355 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1375:35
[INFO] [stderr]      |
[INFO] [stderr] 1375 |         pub expr: std::boxed::Box<AST>,
[INFO] [stderr]      |                                   ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]     --> src/ast.rs:1421:40
[INFO] [stderr]      |
[INFO] [stderr] 1421 |         pub stmts: Vec<std::boxed::Box<AST>>,
[INFO] [stderr]      |                                        ^^^ help: use `dyn`: `dyn AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:78:149
[INFO] [stderr]    |
[INFO] [stderr] 78 |  fn __parse_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = match __parse_program_prologue ( __input , __state , __pos ) { Matched ( __newpos , _ ) => { Matched ( __newpos , ( ) ) } , Failed => { Matched ( __pos , ( ) ) } , } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement_program ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:639
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:653
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:667
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:82:1811
[INFO] [stderr]    |
[INFO] [stderr] 82 |  fn __parse_int_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < i64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "0x" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' | 'a' ... 'f' | 'A' ... 'F' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9a-fA-F]" ) , } } else { __state . mark_failure ( __pos , "[0-9a-fA-F]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  i64::from_str_radix(n, 16).unwrap()  } ) } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<i64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "integer literal" ) ; Failed } } } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:84:548
[INFO] [stderr]    |
[INFO] [stderr] 84 |  fn __parse_float_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < f64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<f64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "float literal" ) ; Failed } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:84:1313
[INFO] [stderr]    |
[INFO] [stderr] 84 |  fn __parse_float_literal < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < f64 > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = { let str_start = __pos ; match { __state . suppress_fail += 1 ; let res = { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , n ) => { Matched ( __pos , {  n.parse::<f64>().unwrap()  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "float literal" ) ; Failed } } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:94:343
[INFO] [stderr]    |
[INFO] [stderr] 94 |  fn __parse_id_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                       ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:94:357
[INFO] [stderr]    |
[INFO] [stderr] 94 |  fn __parse_id_start < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                     ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:343
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                       ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:357
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                     ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: `...` range patterns are deprecated
[INFO] [stderr]   --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:96:383
[INFO] [stderr]    |
[INFO] [stderr] 96 |  fn __parse_id_chars < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < String > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = { let str_start = __pos ; match if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'a' ... 'z' | 'A' ... 'Z' | '$' | '_' | '0' ... '9' | '?' | '!' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) , } } else { __state . mark_failure ( __pos , "[a-zA-Z$_0-9?!]" ) } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; match __seq_res { Matched ( __pos , c ) => { Matched ( __pos , {  c.to_string()  } ) } Failed => Failed , } } } 
[INFO] [stderr]    |                                                                                                                                                                                                                                                                                                                                                                                               ^^^ help: use `..=` for an inclusive range
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:120:145
[INFO] [stderr]     |
[INFO] [stderr] 120 |  fn __parse_value < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_float_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(FloatLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_int_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(IntLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_string_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(StrLiteral, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(Identifier, ps, pe, val: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_array_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_function_expr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } } } } } } } } } } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:122:150
[INFO] [stderr]     |
[INFO] [stderr] 122 |  fn __parse_array_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "]" ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ArrayExpr, ps, pe, exprs: vec![])  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "[" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , fexpr ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , lexpr ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:128:150
[INFO] [stderr]     |
[INFO] [stderr] 128 |  fn __parse_unary_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = { let str_start = __pos ; match { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "not" ) ; match __seq_res { Matched ( __pos , _ ) => { { __state . suppress_fail += 1 ; let __assert_res = match __parse_id_chars ( __input , __state , __pos ) { Matched ( pos , _ ) => Matched ( pos , ( ) ) , Failed => Failed , } ; __state . suppress_fail -= 1 ; match __assert_res { Failed => Matched ( __pos , ( ) ) , Matched ( .. ) => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "-" ) } } { Matched ( __newpos , _ ) => { Matched ( __newpos , & __input [ str_start .. __newpos ] ) } , Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , op ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_value ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , val ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:138:151
[INFO] [stderr]     |
[INFO] [stderr] 138 |  fn __parse_record_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "record" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_record_body_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:144:153
[INFO] [stderr]     |
[INFO] [stderr] 144 |  fn __parse_function_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "function" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , i ) => { Matched ( __pos , { i } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_function_arguments ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:161:144
[INFO] [stderr]     |
[INFO] [stderr] 161 |  fn __parse_expr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_assignmentexpr ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "expression" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:163:154
[INFO] [stderr]     |
[INFO] [stderr] 163 |  fn __parse_assignmentexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_condexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Assign)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Adds)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Subs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Muls)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Divs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "%=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mods)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_condexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:163:395
[INFO] [stderr]     |
[INFO] [stderr] 163 |  fn __parse_assignmentexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_condexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Assign)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Adds)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Subs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Muls)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Divs)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "%=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mods)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_condexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                                                                                                                                                                                                                                                                           ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:165:148
[INFO] [stderr]     |
[INFO] [stderr] 165 |  fn __parse_condexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , cond ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "?" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , then ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ":" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_binexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , alt ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(CondExpr, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:170:147
[INFO] [stderr]     |
[INFO] [stderr] 170 |  fn __parse_binexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_callexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseAnd)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "|" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseOr )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "xor" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseXor )  } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "and" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::And)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "or" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Or )  } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "==" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Eq )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "!=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Neq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Gt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Lt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Geq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Leq)  } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "of" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Of )  } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Add)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Sub)  } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mul)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Div)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "mod" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mod)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_callexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:170:388
[INFO] [stderr]     |
[INFO] [stderr] 170 |  fn __parse_binexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { fn __infix_parse < 'input > ( __min_prec : i32 , __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { if let Matched ( __pos , mut __infix_result ) = __parse_callexpr ( __input , __state , __pos ) { let mut __repeat_pos = __pos ; loop { let __pos = __repeat_pos ; if 0i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "&" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseAnd)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "|" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseOr )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "xor" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 1i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::BitwiseXor )  } ; __repeat_pos = __pos ; continue ; } } } if 1i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "and" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::And)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "or" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 2i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Or )  } ; __repeat_pos = __pos ; continue ; } } } if 2i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "==" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Eq )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "!=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Neq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Gt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Lt )  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ">=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Geq)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "<=" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 3i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Leq)  } ; __repeat_pos = __pos ; continue ; } } } if 3i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "of" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 4i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Of )  } ; __repeat_pos = __pos ; continue ; } } } if 4i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "+" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Add)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "-" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 5i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Sub)  } ; __repeat_pos = __pos ; continue ; } } } if 5i32 >= __min_prec { if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "*" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mul)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "/" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse__ ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Div)  } ; __repeat_pos = __pos ; continue ; } } if let Matched ( __pos , _ ) = { __state . suppress_fail += 1 ; let res = { let __seq_res = __parse_s ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "mod" ) ; match __seq_res { Matched ( __pos , _ ) => { __parse_s ( __input , __state , __pos ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } { if let Matched ( __pos , y ) = __infix_parse ( 6i32 , __input , __state , __pos ) { let x = __infix_result ; __infix_result = { boxed!(BinExpr, x.span().0, y.span().1, left: x, right:y, op: ast::BinOp::Mod)  } ; __repeat_pos = __pos ; continue ; } } } break ; } Matched ( __repeat_pos , __infix_result ) } else { Failed } } __infix_parse ( 0 , __input , __state , __pos ) } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_callexpr ( __input , __state , __pos ) } } } 
[INFO] [stderr]     |                                                                                                                                                                                                                                                                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:172:148
[INFO] [stderr]     |
[INFO] [stderr] 172 |  fn __parse_callexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_memexpr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _left ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_callexpr_args ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_callexpr_arm ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , _right ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:173:28
[INFO] [stderr]     |
[INFO] [stderr] 173 |         let mut left : Box<ast::AST> = boxed!(CallExpr, ps, pe,
[INFO] [stderr]     |                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:211:157
[INFO] [stderr]     |
[INFO] [stderr] 211 |  fn __parse_callexpr_args < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "(" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , farg ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "," ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , {  e  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , larg ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , ")" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                             ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:219:68
[INFO] [stderr]     |
[INFO] [stderr] 219 |             boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "::" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:221:68
[INFO] [stderr]     |
[INFO] [stderr] 221 |             boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "[" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "]" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:229:147
[INFO] [stderr]     |
[INFO] [stderr] 229 |  fn __parse_memexpr < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_unary_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _left ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_memexpr_arm ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , __repeat_value ) } else { Failed } } ; match __seq_res { Matched ( __pos , _right ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:242:152
[INFO] [stderr]     |
[INFO] [stderr] 242 |  fn __parse_memexpr_arm < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < (std::boxed::Box<ast::AST>, bool /* is_expr */, bool /* is_namespace */) > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "." ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                        ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:243:65
[INFO] [stderr]     |
[INFO] [stderr] 243 |         (boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>,
[INFO] [stderr]     |                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:245:65
[INFO] [stderr]     |
[INFO] [stderr] 245 |         (boxed!(Identifier, ps, pe, val: id) as std::boxed::Box<ast::AST>,
[INFO] [stderr]     |                                                                 ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:251:164
[INFO] [stderr]     |
[INFO] [stderr] 251 |  fn __parse_statement_program_no_eos < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_block_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_if_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_while_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_for_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_for_in_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_function_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_try_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_raise_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_use_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_expr_stmt ( __input , __state , __pos ) } } } } } } } } } } } } } } } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:253:157
[INFO] [stderr]     |
[INFO] [stderr] 253 |  fn __parse_statement_program < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_program_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                             ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:255:156
[INFO] [stderr]     |
[INFO] [stderr] 255 |  fn __parse_statement_no_eos < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = __parse_statement_program_no_eos ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_return_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_continue_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_break_stmt ( __input , __state , __pos ) } } } } } } } 
[INFO] [stderr]     |                                                                                                                                                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:257:149
[INFO] [stderr]     |
[INFO] [stderr] 257 |  fn __parse_statement < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement_no_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:259:150
[INFO] [stderr]     |
[INFO] [stderr] 259 |  fn __parse_block_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "begin" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BlockStatement, ps, pe, stmts: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "begin" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BlockStatement, ps, pe, stmts: Vec::new())  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "block statement" ) ; Failed } } } } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 33 |         let vm: Vm = eval!("y = 10");
[INFO] [stderr]    |                      --------------- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(unused_must_use)]` on by default
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 39 |         let vm: Vm = eval!("y = 420.69");
[INFO] [stderr]    |                      ------------------- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 48 |         let vm: Vm = eval!("y = 'test'");
[INFO] [stderr]    |                      ------------------- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 56 |         let vm: Vm = eval!("y = 10");
[INFO] [stderr]    |                      --------------- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 62 |         let vm: Vm = eval!("$y = 10");
[INFO] [stderr]    |                      ---------------- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 70 |         let vm: Vm = eval!("y = 2*(3+5)");
[INFO] [stderr]    |                      -------------------- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:261:149
[INFO] [stderr]     |
[INFO] [stderr] 261 |  fn __parse_then_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { __state . suppress_fail += 1 ; let res = { let __seq_res = slice_eq ( __input , __state , __pos , "then" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = { __state . suppress_fail += 1 ; let res = __parse_block_stmt ( __input , __state , __pos ) ; __state . suppress_fail -= 1 ; res } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "block or then <stmt>" ) ; Failed } } } } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:263:147
[INFO] [stderr]     |
[INFO] [stderr] 263 |  fn __parse_if_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "if" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = match { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "else" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , a ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(IfStatement, ps, pe, expr: e, then: s, alt: a)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                   ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:265:150
[INFO] [stderr]     |
[INFO] [stderr] 265 |  fn __parse_while_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "while" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(WhileStatement, ps, pe, expr: e, then: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:267:148
[INFO] [stderr]     |
[INFO] [stderr] 267 |  fn __parse_for_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "for" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "=" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , from ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let __choice_res = { let __seq_res = slice_eq ( __input , __state , __pos , "to" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  true  } ) } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __seq_res = slice_eq ( __input , __state , __pos , "downto" ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  false  } ) } Failed => Failed , } } } } ; match __seq_res { Matched ( __pos , dir ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , to ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "step" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , step ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:280:151
[INFO] [stderr]     |
[INFO] [stderr] 280 |  fn __parse_for_in_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "for" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "in" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expr ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_then_stmt ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:287:153
[INFO] [stderr]     |
[INFO] [stderr] 287 |  fn __parse_continue_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "continue" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ContinueStatement, ps, pe,)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:289:150
[INFO] [stderr]     |
[INFO] [stderr] 289 |  fn __parse_break_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "break" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(BreakStatement, ps, pe,)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:291:148
[INFO] [stderr]     |
[INFO] [stderr] 291 |  fn __parse_try_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "try" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_statement ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , stmts ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_case_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , cases ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(TryStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 77 |             let vm: Vm = eval!("y = 2&5");
[INFO] [stderr]    |                          ---------------- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 81 |             let vm: Vm = eval!("y = 2|5");
[INFO] [stderr]    |                          ---------------- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 85 |             let vm: Vm = eval!("y = 2 xor 5");
[INFO] [stderr]    |                          -------------------- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 92 |         let vm: Vm = eval!("y = 1 > 0");
[INFO] [stderr]    |                      ------------------ in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/interpreter.rs:20:17
[INFO] [stderr]    |
[INFO] [stderr] 20 |                 stmt.emit(&mut c);
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 98 |         let vm: Vm = eval!("y = 1 < 0");
[INFO] [stderr]    |                      ------------------ in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                 stmt.emit(&mut c);
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 104 |         let vm: Vm = eval!("y = 0 >= 0");
[INFO] [stderr]     |                      ------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                 stmt.emit(&mut c);
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 110 |         let vm: Vm = eval!("y = 0 <= 0");
[INFO] [stderr]     |                      ------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                 stmt.emit(&mut c);
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 116 |         let vm: Vm = eval!("y = 0 == 0");
[INFO] [stderr]     |                      ------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                 stmt.emit(&mut c);
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 122 |         let vm: Vm = eval!("y = 5 and 0");
[INFO] [stderr]     |                      -------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                 stmt.emit(&mut c);
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 128 |         let vm: Vm = eval!("y = 5 or 0");
[INFO] [stderr]     |                      ------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                 stmt.emit(&mut c);
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 134 |         let vm: Vm = eval!("y = 1 ? 2*2 : 0");
[INFO] [stderr]     |                      ------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:300:150
[INFO] [stderr]     |
[INFO] [stderr] 300 |  fn __parse_raise_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "raise" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , expr ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(RaiseStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                      ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:303:148
[INFO] [stderr]     |
[INFO] [stderr] 303 |  fn __parse_use_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "use" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_string_literal ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , path ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(UseStatement, ps, pe,
[INFO] [stderr]     |                                                                                                                                                    ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:318:153
[INFO] [stderr]     |
[INFO] [stderr] 318 |  fn __parse_function_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "function" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_word ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_function_arguments ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , args ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_statement ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                         ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:327:151
[INFO] [stderr]     |
[INFO] [stderr] 327 |  fn __parse_return_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "return" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = match { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , e ) => { Matched ( __pos , { e } ) } Failed => Failed , } } } Failed => Failed , } } { Matched ( __newpos , __value ) => { Matched ( __newpos , Some ( __value ) ) } , Failed => { Matched ( __pos , None ) } , } ; match __seq_res { Matched ( __pos , e ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ReturnStatement, ps, pe, expr: e)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:329:156
[INFO] [stderr]     |
[INFO] [stderr] 329 |  fn __parse_record_body_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __choice_res = { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let __choice_res = __parse_function_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { let __choice_res = __parse_record_stmt ( __input , __state , __pos ) ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => __parse_expr_stmt ( __input , __state , __pos ) } } } } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse___ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { Matched ( __pos , {  s  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } ; match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => { __state . mark_failure ( __pos , "statement" ) ; Failed } } } } 
[INFO] [stderr]     |                                                                                                                                                            ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:331:151
[INFO] [stderr]     |
[INFO] [stderr] 331 |  fn __parse_record_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = { __state . suppress_fail += 1 ; let res = slice_eq ( __input , __state , __pos , "record" ) ; __state . suppress_fail -= 1 ; res } ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_identifier ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , id ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! ( ) ; loop { let __pos = __repeat_pos ; let __step_res = __parse_record_body_stmt ( __input , __state , __pos ) ; match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } } Matched ( __repeat_pos , __repeat_value ) } ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse__ ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = slice_eq ( __input , __state , __pos , "end" ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , { 
[INFO] [stderr]     |                                                                                                                                                       ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:339:149
[INFO] [stderr]     |
[INFO] [stderr] 339 |  fn __parse_expr_stmt < 'input > ( __input : & 'input str , __state : & mut ParseState < 'input > , __pos : usize ) -> RuleResult < std::boxed::Box<ast::AST> > { # ! [ allow ( non_snake_case , unused ) ] { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , ps ) => { { let __seq_res = __parse_expr ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , s ) => { { let __seq_res = __parse_eos ( __input , __state , __pos ) ; match __seq_res { Matched ( __pos , _ ) => { { let __seq_res = Matched ( __pos , __pos ) ; match __seq_res { Matched ( __pos , pe ) => { Matched ( __pos , {  boxed!(ExprStatement, ps, pe, expr: s)  } ) } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } Failed => Failed , } } } 
[INFO] [stderr]     |                                                                                                                                                     ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]    --> /opt/rustwide/target/debug/build/haru-78ca73c5fa289fab/out/parser.rs:341:90
[INFO] [stderr]     |
[INFO] [stderr] 341 |  pub fn start < 'input > ( __input : & 'input str ) -> ParseResult < Vec<std::boxed::Box<ast::AST>> > { # ! [ allow ( non_snake_case , unused ) ] let mut __state = ParseState :: new ( ) ; match __parse_start ( __input , & mut __state , 0 ) { Matched ( __pos , __value ) => { if __pos == __input . len ( ) { return Ok ( __value ) } } _ => { } } let ( __line , __col ) = pos_to_line ( __input , __state . max_err_pos ) ; Err ( ParseError { line : __line , column : __col , offset : __state . max_err_pos , expected : __state . expected , } ) }
[INFO] [stderr]     |                                                                                          ^^^^^^^^ help: use `dyn`: `dyn ast::AST`
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 140 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 141 | |             "
[INFO] [stderr] 142 | | a = 0
[INFO] [stderr] 143 | | a += 1
[INFO] [stderr] 144 | | "
[INFO] [stderr] 145 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stderr]   --> src/vmbindings/record.rs:19:34
[INFO] [stderr]    |
[INFO] [stderr] 19 |     pub native_field: Option<Box<Any>>,
[INFO] [stderr]    |                                  ^^^ help: use `dyn`: `dyn Any`
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 151 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 152 | |             "
[INFO] [stderr] 153 | | a = 'a'
[INFO] [stderr] 154 | | a += 'b'
[INFO] [stderr] 155 | | "
[INFO] [stderr] 156 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 165 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 166 | |             "
[INFO] [stderr] 167 | | a = ['b','c']
[INFO] [stderr] 168 | | y = 'a'
[INFO] [stderr] 169 | | y += a[0]
[INFO] [stderr] 170 | | "
[INFO] [stderr] 171 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::vmbindings::interned_string_map::InternedStringMap`
[INFO] [stderr]  --> src/hanayo/eval.rs:4:5
[INFO] [stderr]   |
[INFO] [stderr] 4 | use crate::vmbindings::interned_string_map::InternedStringMap;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 180 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 181 | |             "
[INFO] [stderr] 182 | | a = ['a','c']
[INFO] [stderr] 183 | | a[0] += 'b'
[INFO] [stderr] 184 | | y = a[0]
[INFO] [stderr] 185 | | "
[INFO] [stderr] 186 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 195 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 196 | |             "
[INFO] [stderr] 197 | | record a
[INFO] [stderr] 198 | |     y = 'a'
[INFO] [stderr] ...   |
[INFO] [stderr] 202 | | "
[INFO] [stderr] 203 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 212 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 213 | |             "
[INFO] [stderr] 214 | | x = 'a'
[INFO] [stderr] 215 | | x *= 3
[INFO] [stderr] 216 | | "
[INFO] [stderr] 217 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 228 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 229 | |             "
[INFO] [stderr] 230 | | if 0 then y = 1
[INFO] [stderr] 231 | | "
[INFO] [stderr] 232 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 238 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 239 | |             "
[INFO] [stderr] 240 | | if 0 then y = 1
[INFO] [stderr] 241 | | else y = 2
[INFO] [stderr] 242 | | "
[INFO] [stderr] 243 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 251 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 252 | |             "
[INFO] [stderr] 253 | | i = 0
[INFO] [stderr] 254 | | while i < 10 begin
[INFO] [stderr] ...   |
[INFO] [stderr] 257 | | "
[INFO] [stderr] 258 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 266 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 267 | |             "
[INFO] [stderr] 268 | | for i=0 to 10 begin
[INFO] [stderr] 269 | | end
[INFO] [stderr] 270 | | "
[INFO] [stderr] 271 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 277 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 278 | |             "
[INFO] [stderr] 279 | | for i=10 downto 0 begin
[INFO] [stderr] 280 | | end
[INFO] [stderr] 281 | | "
[INFO] [stderr] 282 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 288 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 289 | |             "
[INFO] [stderr] 290 | | for i in [1,2,3,10] begin
[INFO] [stderr] 291 | | end
[INFO] [stderr] 292 | | "
[INFO] [stderr] 293 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 299 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 300 | |             "
[INFO] [stderr] 301 | | for i in [] begin
[INFO] [stderr] 302 | | end
[INFO] [stderr] 303 | | "
[INFO] [stderr] 304 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 311 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 312 | |             "
[INFO] [stderr] 313 | | y = 0
[INFO] [stderr] 314 | | for i in 'abcd' begin
[INFO] [stderr] ...   |
[INFO] [stderr] 317 | | "
[INFO] [stderr] 318 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 324 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 325 | |             "
[INFO] [stderr] 326 | | record x
[INFO] [stderr] 327 | |
[INFO] [stderr] ...   |
[INFO] [stderr] 342 | | "
[INFO] [stderr] 343 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 353 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 354 | |             "
[INFO] [stderr] 355 | | for i=0 to 10 begin
[INFO] [stderr] 356 | | if i == 5 then break
[INFO] [stderr] 357 | | end
[INFO] [stderr] 358 | | "
[INFO] [stderr] 359 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 367 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 368 | |             "
[INFO] [stderr] 369 | | function A() begin
[INFO] [stderr] 370 | | end
[INFO] [stderr] 371 | | "
[INFO] [stderr] 372 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 380 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 381 | |             "
[INFO] [stderr] 382 | | function A() begin
[INFO] [stderr] 383 | | return 10
[INFO] [stderr] ...   |
[INFO] [stderr] 386 | | "
[INFO] [stderr] 387 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 392 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 393 | |             "
[INFO] [stderr] 394 | | function A(x) begin
[INFO] [stderr] 395 | | return 10+x
[INFO] [stderr] ...   |
[INFO] [stderr] 398 | | "
[INFO] [stderr] 399 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 405 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 406 | |             "
[INFO] [stderr] 407 | | $x = 1
[INFO] [stderr] 408 | | function outer() begin
[INFO] [stderr] ...   |
[INFO] [stderr] 418 | | "
[INFO] [stderr] 419 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 426 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 427 | |             "
[INFO] [stderr] 428 | | (function() begin
[INFO] [stderr] 429 | |
[INFO] [stderr] ...   |
[INFO] [stderr] 440 | | "
[INFO] [stderr] 441 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 446 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 447 | |             "
[INFO] [stderr] 448 | | (function() begin
[INFO] [stderr] 449 | | $y = 0
[INFO] [stderr] 450 | | end)()
[INFO] [stderr] 451 | | "
[INFO] [stderr] 452 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 457 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 458 | |             "
[INFO] [stderr] 459 | | fib(n) = n <= 1 ? 1 : fib(n-1) + fib(n-2)
[INFO] [stderr] 460 | | "
[INFO] [stderr] 461 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 469 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 470 | |             "
[INFO] [stderr] 471 | | function a() begin
[INFO] [stderr] 472 | |     return 1
[INFO] [stderr] ...   |
[INFO] [stderr] 477 | | "
[INFO] [stderr] 478 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 483 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 484 | |             "
[INFO] [stderr] 485 | | y = 0
[INFO] [stderr] 486 | | function a() begin
[INFO] [stderr] ...   |
[INFO] [stderr] 492 | | "
[INFO] [stderr] 493 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 498 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 499 | |             "
[INFO] [stderr] 500 | | a(x) = x == 1000 ? x : a(x+1)
[INFO] [stderr] 501 | | y = a(0)
[INFO] [stderr] 502 | | "
[INFO] [stderr] 503 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 508 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 509 | |             "
[INFO] [stderr] 510 | | x = [_() = 0]
[INFO] [stderr] 511 | | y = x[0]
[INFO] [stderr] 512 | | z = y()
[INFO] [stderr] 513 | | "
[INFO] [stderr] 514 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 533 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 534 | |             "
[INFO] [stderr] 535 | | try
[INFO] [stderr] 536 | |     y = 10
[INFO] [stderr] 537 | | end
[INFO] [stderr] 538 | | "
[INFO] [stderr] 539 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 545 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 546 | |             "
[INFO] [stderr] 547 | | raise 0
[INFO] [stderr] 548 | | "
[INFO] [stderr] 549 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 555 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 556 | |             "
[INFO] [stderr] 557 | | record A
[INFO] [stderr] 558 | |     function constructor(self) begin
[INFO] [stderr] ...   |
[INFO] [stderr] 567 | | "
[INFO] [stderr] 568 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 576 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 577 | |             "
[INFO] [stderr] 578 | | record A
[INFO] [stderr] 579 | | end
[INFO] [stderr] 580 | | "
[INFO] [stderr] 581 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 587 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 588 | |             "
[INFO] [stderr] 589 | | record A
[INFO] [stderr] 590 | |     y = 0
[INFO] [stderr] ...   |
[INFO] [stderr] 595 | | "
[INFO] [stderr] 596 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 607 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 608 | |             "
[INFO] [stderr] 609 | | record A
[INFO] [stderr] 610 | | end
[INFO] [stderr] 611 | | y = A.x
[INFO] [stderr] 612 | | "
[INFO] [stderr] 613 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 619 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 620 | |             "
[INFO] [stderr] 621 | | record A
[INFO] [stderr] 622 | |     x = 10
[INFO] [stderr] ...   |
[INFO] [stderr] 625 | | "
[INFO] [stderr] 626 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 632 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 633 | |             "
[INFO] [stderr] 634 | | record A
[INFO] [stderr] 635 | |     x = 10
[INFO] [stderr] ...   |
[INFO] [stderr] 639 | | "
[INFO] [stderr] 640 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 645 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 646 | |             "
[INFO] [stderr] 647 | | record A
[INFO] [stderr] 648 | |     x = 10
[INFO] [stderr] ...   |
[INFO] [stderr] 653 | | "
[INFO] [stderr] 654 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 659 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 660 | |             "
[INFO] [stderr] 661 | | record A
[INFO] [stderr] 662 | |     x = 10
[INFO] [stderr] ...   |
[INFO] [stderr] 667 | | "
[INFO] [stderr] 668 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 674 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 675 | |             "
[INFO] [stderr] 676 | | record A
[INFO] [stderr] 677 | |     y = 0
[INFO] [stderr] ...   |
[INFO] [stderr] 683 | | "
[INFO] [stderr] 684 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 691 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 692 | |             "
[INFO] [stderr] 693 | | record A
[INFO] [stderr] 694 | |     y = 0
[INFO] [stderr] ...   |
[INFO] [stderr] 700 | | "
[INFO] [stderr] 701 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 708 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 709 | |             "
[INFO] [stderr] 710 | | record A
[INFO] [stderr] 711 | |     y = 'a'
[INFO] [stderr] ...   |
[INFO] [stderr] 717 | | "
[INFO] [stderr] 718 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 728 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 729 | |             "
[INFO] [stderr] 730 | | record A
[INFO] [stderr] 731 | |     function constructor(self) begin
[INFO] [stderr] ...   |
[INFO] [stderr] 737 | | "
[INFO] [stderr] 738 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 748 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 749 | |             "
[INFO] [stderr] 750 | | record A
[INFO] [stderr] 751 | |     function constructor(self) begin
[INFO] [stderr] ...   |
[INFO] [stderr] 762 | | "
[INFO] [stderr] 763 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 771 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 772 | |             "
[INFO] [stderr] 773 | | a = []
[INFO] [stderr] 774 | | "
[INFO] [stderr] 775 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 781 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 782 | |             "
[INFO] [stderr] 783 | | a = [1]*5
[INFO] [stderr] 784 | | "
[INFO] [stderr] 785 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 792 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 793 | |             "
[INFO] [stderr] 794 | | a = ['a', 'b']
[INFO] [stderr] 795 | | "
[INFO] [stderr] 796 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 805 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 806 | |             "
[INFO] [stderr] 807 | | a = ['a', 'b']
[INFO] [stderr] 808 | | y = a[0]
[INFO] [stderr] 809 | | "
[INFO] [stderr] 810 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 819 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 820 | |             "
[INFO] [stderr] 821 | | a = ['a', 'b']
[INFO] [stderr] 822 | | a[0] = 'x'
[INFO] [stderr] 823 | | y = a[0]
[INFO] [stderr] 824 | | "
[INFO] [stderr] 825 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:20:17
[INFO] [stderr]     |
[INFO] [stderr] 20  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 836 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 837 | |             "
[INFO] [stderr] 838 | | a = 'abcdef'
[INFO] [stderr] 839 | | y = a[0]
[INFO] [stderr] 840 | | "
[INFO] [stderr] 841 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:862:13
[INFO] [stderr]     |
[INFO] [stderr] 862 |             stmt.emit(&mut c);
[INFO] [stderr]     |             ^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:882:13
[INFO] [stderr]     |
[INFO] [stderr] 882 |             stmt.emit(&mut c);
[INFO] [stderr]     |             ^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/interpreter.rs:903:13
[INFO] [stderr]     |
[INFO] [stderr] 903 |             stmt.emit(&mut c);
[INFO] [stderr]     |             ^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/hanayo.rs:21:17
[INFO] [stderr]    |
[INFO] [stderr] 21 |                   stmt.emit(&mut c);
[INFO] [stderr]    |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 35 |           let vm: Vm = eval!(
[INFO] [stderr]    |  ______________________-
[INFO] [stderr] 36 | |             "
[INFO] [stderr] 37 | | y = 1 of Int
[INFO] [stderr] 38 | | "
[INFO] [stderr] 39 | |         );
[INFO] [stderr]    | |_________- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(unused_must_use)]` on by default
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/hanayo.rs:21:17
[INFO] [stderr]    |
[INFO] [stderr] 21 |                   stmt.emit(&mut c);
[INFO] [stderr]    |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 45 |           let vm: Vm = eval!(
[INFO] [stderr]    |  ______________________-
[INFO] [stderr] 46 | |             "
[INFO] [stderr] 47 | | record Y
[INFO] [stderr] 48 | | end
[INFO] [stderr] ...  |
[INFO] [stderr] 53 | | "
[INFO] [stderr] 54 | |         );
[INFO] [stderr]    | |_________- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/hanayo.rs:21:17
[INFO] [stderr]    |
[INFO] [stderr] 21 |                   stmt.emit(&mut c);
[INFO] [stderr]    |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 60 |           let vm: Vm = eval!(
[INFO] [stderr]    |  ______________________-
[INFO] [stderr] 61 | |             "
[INFO] [stderr] 62 | | record Z
[INFO] [stderr] 63 | | end
[INFO] [stderr] ...  |
[INFO] [stderr] 71 | | "
[INFO] [stderr] 72 | |         );
[INFO] [stderr]    | |_________- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> tests/hanayo.rs:21:17
[INFO] [stderr]    |
[INFO] [stderr] 21 |                   stmt.emit(&mut c);
[INFO] [stderr]    |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 77 |           let vm: Vm = eval!(
[INFO] [stderr]    |  ______________________-
[INFO] [stderr] 78 | |             "
[INFO] [stderr] 79 | | record Z
[INFO] [stderr] 80 | | end
[INFO] [stderr] ...  |
[INFO] [stderr] 90 | | "
[INFO] [stderr] 91 | |         );
[INFO] [stderr]    | |_________- in this macro invocation
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 97  |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 98  | |             "
[INFO] [stderr] 99  | | y = (10).prototype == Int
[INFO] [stderr] 100 | | "
[INFO] [stderr] 101 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 107 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 108 | |             "
[INFO] [stderr] 109 | | [1,2,3].map(print)
[INFO] [stderr] 110 | | "
[INFO] [stderr] 111 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 119 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 120 | |             "
[INFO] [stderr] 121 | | y = Int(1)
[INFO] [stderr] 122 | | "
[INFO] [stderr] 123 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 128 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 129 | |             "
[INFO] [stderr] 130 | | y = Int(1.2)
[INFO] [stderr] 131 | | "
[INFO] [stderr] 132 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 137 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 138 | |             "
[INFO] [stderr] 139 | | y = Int('10')
[INFO] [stderr] 140 | | "
[INFO] [stderr] 141 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 146 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 147 | |             "
[INFO] [stderr] 148 | | try
[INFO] [stderr] 149 | |     Int('1?')
[INFO] [stderr] ...   |
[INFO] [stderr] 153 | | "
[INFO] [stderr] 154 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 159 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 160 | |             "
[INFO] [stderr] 161 | | try
[INFO] [stderr] 162 | |     Int([0])
[INFO] [stderr] ...   |
[INFO] [stderr] 166 | | "
[INFO] [stderr] 167 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 173 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 174 | |             "
[INFO] [stderr] 175 | | y = (97).chr()
[INFO] [stderr] 176 | | "
[INFO] [stderr] 177 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 183 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 184 | |             "
[INFO] [stderr] 185 | | y = (16).hex()
[INFO] [stderr] 186 | | "
[INFO] [stderr] 187 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 195 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 196 | |             "
[INFO] [stderr] 197 | | y = Float(1.0)
[INFO] [stderr] 198 | | "
[INFO] [stderr] 199 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 204 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 205 | |             "
[INFO] [stderr] 206 | | y = Float(1)
[INFO] [stderr] 207 | | "
[INFO] [stderr] 208 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 213 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 214 | |             "
[INFO] [stderr] 215 | | y = Float('10.55')
[INFO] [stderr] 216 | | "
[INFO] [stderr] 217 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 222 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 223 | |             "
[INFO] [stderr] 224 | | try
[INFO] [stderr] 225 | |     Float('1?')
[INFO] [stderr] ...   |
[INFO] [stderr] 229 | | "
[INFO] [stderr] 230 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 235 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 236 | |             "
[INFO] [stderr] 237 | | try
[INFO] [stderr] 238 | |     Float([0])
[INFO] [stderr] ...   |
[INFO] [stderr] 242 | | "
[INFO] [stderr] 243 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 251 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 252 | |             "
[INFO] [stderr] 253 | | y = Array()
[INFO] [stderr] 254 | | "
[INFO] [stderr] 255 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 262 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 263 | |             "
[INFO] [stderr] 264 | | y = Array(1,2,3)
[INFO] [stderr] 265 | | "
[INFO] [stderr] 266 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 276 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 277 | |             "
[INFO] [stderr] 278 | | y = [1,2,3].length()
[INFO] [stderr] 279 | | "
[INFO] [stderr] 280 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 286 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 287 | |             "
[INFO] [stderr] 288 | | y = [1,2,3]
[INFO] [stderr] 289 | | y.delete!(1,1)
[INFO] [stderr] 290 | | "
[INFO] [stderr] 291 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 300 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 301 | |             "
[INFO] [stderr] 302 | | y = []
[INFO] [stderr] 303 | | y.push(10)
[INFO] [stderr] 304 | | "
[INFO] [stderr] 305 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 313 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 314 | |             "
[INFO] [stderr] 315 | | y = [1,2]
[INFO] [stderr] 316 | | y.pop()
[INFO] [stderr] 317 | | "
[INFO] [stderr] 318 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 326 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 327 | |             "
[INFO] [stderr] 328 | | a = ['a', 'b', 'c']
[INFO] [stderr] 329 | | y = a.index('b')
[INFO] [stderr] 330 | | "
[INFO] [stderr] 331 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 337 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 338 | |             "
[INFO] [stderr] 339 | | y = [1,2,3]
[INFO] [stderr] 340 | | y.insert!(1, 4)
[INFO] [stderr] 341 | | "
[INFO] [stderr] 342 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 353 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 354 | |             "
[INFO] [stderr] 355 | | y = [6,3,1]
[INFO] [stderr] 356 | | y.sort!()
[INFO] [stderr] 357 | | "
[INFO] [stderr] 358 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 367 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 368 | |             "
[INFO] [stderr] 369 | | x = [6,3,1]
[INFO] [stderr] 370 | | y = x.sort()
[INFO] [stderr] 371 | | "
[INFO] [stderr] 372 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 382 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 383 | |             "
[INFO] [stderr] 384 | | a=[3,5,64,2]
[INFO] [stderr] 385 | | y = a.map(f(x) = x+1)
[INFO] [stderr] 386 | | "
[INFO] [stderr] 387 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 398 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 399 | |             "
[INFO] [stderr] 400 | | a=['1','2','3']
[INFO] [stderr] 401 | | y = a.map(Int)
[INFO] [stderr] 402 | | "
[INFO] [stderr] 403 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 413 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 414 | |             "
[INFO] [stderr] 415 | | a=[3,5,64,2]
[INFO] [stderr] 416 | | y = a.filter(f(x) = x>5)
[INFO] [stderr] 417 | | "
[INFO] [stderr] 418 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 426 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 427 | |             "
[INFO] [stderr] 428 | | a=[1,2,3,4,5]
[INFO] [stderr] 429 | | y = a.reduce(f(x, y) = x + y, 0)
[INFO] [stderr] 430 | | "
[INFO] [stderr] 431 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 437 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 438 | |             "
[INFO] [stderr] 439 | | a=[1,2,3,5,6]
[INFO] [stderr] 440 | | y = a.map(_(x) = x+1).filter(_(x) = x>5).reduce(_(prev, curr) = prev+curr, 0)
[INFO] [stderr] 441 | | "
[INFO] [stderr] 442 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 448 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 449 | |             "
[INFO] [stderr] 450 | | a=[1,2,3,4,5,6]
[INFO] [stderr] 451 | | y = a.join('')
[INFO] [stderr] 452 | | "
[INFO] [stderr] 453 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 461 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 462 | |             "
[INFO] [stderr] 463 | | y = String()
[INFO] [stderr] 464 | | "
[INFO] [stderr] 465 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 471 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 472 | |             "
[INFO] [stderr] 473 | | y = String(10)
[INFO] [stderr] 474 | | "
[INFO] [stderr] 475 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 481 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 482 | |             "
[INFO] [stderr] 483 | | y = '日本'.length()
[INFO] [stderr] 484 | | "
[INFO] [stderr] 485 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 491 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 492 | |             "
[INFO] [stderr] 493 | | y = '日本'.bytesize()
[INFO] [stderr] 494 | | "
[INFO] [stderr] 495 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 501 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 502 | |             "
[INFO] [stderr] 503 | | y = 'abc'.startswith?('a')
[INFO] [stderr] 504 | | "
[INFO] [stderr] 505 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 511 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 512 | |             "
[INFO] [stderr] 513 | | y = 'abc'.endswith?('bc')
[INFO] [stderr] 514 | | "
[INFO] [stderr] 515 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 521 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 522 | |             "
[INFO] [stderr] 523 | | s = 'λκj'
[INFO] [stderr] 524 | | y = s.delete(1,1)
[INFO] [stderr] 525 | | "
[INFO] [stderr] 526 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 531 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 532 | |             "
[INFO] [stderr] 533 | | s = 'λκj'
[INFO] [stderr] 534 | | y = s.delete(1,-1)
[INFO] [stderr] 535 | | "
[INFO] [stderr] 536 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 541 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 542 | |             "
[INFO] [stderr] 543 | | s = 'λκj'
[INFO] [stderr] 544 | | s.delete!(1,1)
[INFO] [stderr] 545 | | "
[INFO] [stderr] 546 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 551 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 552 | |             "
[INFO] [stderr] 553 | | s = 'λκj'
[INFO] [stderr] 554 | | s.delete!(1,-1)
[INFO] [stderr] 555 | | "
[INFO] [stderr] 556 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 562 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 563 | |             "
[INFO] [stderr] 564 | | s = 'λκj'
[INFO] [stderr] 565 | | y = s.copy(1,2)
[INFO] [stderr] 566 | | "
[INFO] [stderr] 567 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 572 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 573 | |             "
[INFO] [stderr] 574 | | s = 'λκj'
[INFO] [stderr] 575 | | y = s.copy(1,-1)
[INFO] [stderr] 576 | | "
[INFO] [stderr] 577 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 583 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 584 | |             "
[INFO] [stderr] 585 | | s = 'λκj'
[INFO] [stderr] 586 | | y = s.index('κ')
[INFO] [stderr] 587 | | "
[INFO] [stderr] 588 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 594 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 595 | |             "
[INFO] [stderr] 596 | | s = 'λκj'
[INFO] [stderr] 597 | | s.insert!(1,'a')
[INFO] [stderr] 598 | | "
[INFO] [stderr] 599 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 605 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 606 | |             "
[INFO] [stderr] 607 | | s = 'a b c'
[INFO] [stderr] 608 | | y = s.split(' ')
[INFO] [stderr] 609 | | "
[INFO] [stderr] 610 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 620 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 621 | |             "
[INFO] [stderr] 622 | | s = 'λκj'
[INFO] [stderr] 623 | | y = s.chars()
[INFO] [stderr] 624 | | "
[INFO] [stderr] 625 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 635 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 636 | |             "
[INFO] [stderr] 637 | | s = 'a'
[INFO] [stderr] 638 | | y = s.ord()
[INFO] [stderr] 639 | | "
[INFO] [stderr] 640 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 648 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 649 | |             "
[INFO] [stderr] 650 | | y = Record()
[INFO] [stderr] 651 | | "
[INFO] [stderr] 652 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 658 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 659 | |             "
[INFO] [stderr] 660 | | record x
[INFO] [stderr] 661 | |     a = 10
[INFO] [stderr] ...   |
[INFO] [stderr] 665 | | "
[INFO] [stderr] 666 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 672 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 673 | |             "
[INFO] [stderr] 674 | | record x
[INFO] [stderr] 675 | |     a = 10
[INFO] [stderr] ...   |
[INFO] [stderr] 679 | | "
[INFO] [stderr] 680 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 689 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 690 | |             "
[INFO] [stderr] 691 | | y = Env::get('test_key')
[INFO] [stderr] 692 | | "
[INFO] [stderr] 693 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 699 | /         eval!(
[INFO] [stderr] 700 | |             "
[INFO] [stderr] 701 | | Env::set('test_key_set', 'value')
[INFO] [stderr] 702 | | "
[INFO] [stderr] 703 | |         );
[INFO] [stderr]     | |__________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 710 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 711 | |             "
[INFO] [stderr] 712 | | y = Env::vars()['a_key']
[INFO] [stderr] 713 | | "
[INFO] [stderr] 714 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:722:9
[INFO] [stderr]     |
[INFO] [stderr] 722 |         std::fs::write("/tmp/file_read", "test");
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 723 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 724 | |             "
[INFO] [stderr] 725 | | f = File('/tmp/file_read', 'r')
[INFO] [stderr] 726 | | y = f.read()
[INFO] [stderr] 727 | | f.close()
[INFO] [stderr] 728 | | "
[INFO] [stderr] 729 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:735:9
[INFO] [stderr]     |
[INFO] [stderr] 735 |         std::fs::write("/tmp/file_read_up_to", "test");
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 736 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 737 | |             "
[INFO] [stderr] 738 | | f = File('/tmp/file_read_up_to', 'r')
[INFO] [stderr] 739 | | y = f.read_up_to(2)
[INFO] [stderr] 740 | | "
[INFO] [stderr] 741 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 747 | /         eval!(
[INFO] [stderr] 748 | |             "
[INFO] [stderr] 749 | | f = File('/tmp/file_write', 'wc')
[INFO] [stderr] 750 | | f.write('Hello World')
[INFO] [stderr] 751 | | f.close()
[INFO] [stderr] 752 | | "
[INFO] [stderr] 753 | |         );
[INFO] [stderr]     | |__________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 764 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 765 | |             "
[INFO] [stderr] 766 | | y = Cmd(['echo', 'hello world']).out()
[INFO] [stderr] 767 | | "
[INFO] [stderr] 768 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 776 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 777 | |             "
[INFO] [stderr] 778 | | try
[INFO] [stderr] 779 | |     Cmd([1]).out()
[INFO] [stderr] ...   |
[INFO] [stderr] 783 | | "
[INFO] [stderr] 784 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 790 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 791 | |             "
[INFO] [stderr] 792 | | y = Cmd('echo hello world').out()
[INFO] [stderr] 793 | | "
[INFO] [stderr] 794 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 802 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 803 | |             "
[INFO] [stderr] 804 | | try
[INFO] [stderr] 805 | |     Cmd(1).out()
[INFO] [stderr] ...   |
[INFO] [stderr] 809 | | "
[INFO] [stderr] 810 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 816 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 817 | |             "
[INFO] [stderr] 818 | | y = Cmd('echo hello world >&2').err()
[INFO] [stderr] 819 | | "
[INFO] [stderr] 820 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 829 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 830 | |             "
[INFO] [stderr] 831 | | y = Cmd('cat -').in('nyaaa').out()
[INFO] [stderr] 832 | | "
[INFO] [stderr] 833 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 839 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 840 | |             "
[INFO] [stderr] 841 | | y = Cmd('echo hello world').outputs()
[INFO] [stderr] 842 | | "
[INFO] [stderr] 843 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 854 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 855 | |             "
[INFO] [stderr] 856 | | y = Cmd('echo hello world >&2').spawn().err()
[INFO] [stderr] 857 | | "
[INFO] [stderr] 858 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 867 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 868 | |             "
[INFO] [stderr] 869 | | y = Cmd('cat -').spawn().in('nyaaa').out()
[INFO] [stderr] 870 | | "
[INFO] [stderr] 871 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 877 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 878 | |             "
[INFO] [stderr] 879 | | y = Cmd('echo hello world').spawn().outputs()
[INFO] [stderr] 880 | | "
[INFO] [stderr] 881 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 890 |           let _vm: Vm = eval!(
[INFO] [stderr]     |  _______________________-
[INFO] [stderr] 891 | |             "
[INFO] [stderr] 892 | | y = Cmd('sleep 1s').spawn().wait()
[INFO] [stderr] 893 | | "
[INFO] [stderr] 894 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 899 |           let _vm: Vm = eval!(
[INFO] [stderr]     |  _______________________-
[INFO] [stderr] 900 | |             "
[INFO] [stderr] 901 | | y = Cmd('sleep 1s').spawn().kill()
[INFO] [stderr] 902 | | "
[INFO] [stderr] 903 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 910 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 911 | |             "
[INFO] [stderr] 912 | | y = sqrt(4.0)
[INFO] [stderr] 913 | | "
[INFO] [stderr] 914 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 922 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 923 | |             "
[INFO] [stderr] 924 | | eval('y = 10')
[INFO] [stderr] 925 | | "
[INFO] [stderr] 926 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> tests/hanayo.rs:21:17
[INFO] [stderr]     |
[INFO] [stderr] 21  |                   stmt.emit(&mut c);
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 931 |           let vm: Vm = eval!(
[INFO] [stderr]     |  ______________________-
[INFO] [stderr] 932 | |             r#"
[INFO] [stderr] 933 | | eval('y = "a"')
[INFO] [stderr] 934 | | "#
[INFO] [stderr] 935 | |         );
[INFO] [stderr]     | |_________- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stderr] 
[INFO] [stderr] warning: method is never used: `disable`
[INFO] [stderr]    --> src/vmbindings/gc.rs:117:5
[INFO] [stderr]     |
[INFO] [stderr] 117 |     pub fn disable(&mut self) {
[INFO] [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(dead_code)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: method is never used: `get`
[INFO] [stderr]   --> src/vmbindings/interned_string_map.rs:37:5
[INFO] [stderr]    |
[INFO] [stderr] 37 |     pub fn get(&self, idx: u16) -> Option<&Rc<String>> {
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: field is never read: `pointer`
[INFO] [stderr]   --> src/vmbindings/vm.rs:32:5
[INFO] [stderr]    |
[INFO] [stderr] 32 |     pointer: std::num::NonZeroUsize,
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: foreign function is never used: `vm_print_stack`
[INFO] [stderr]    --> src/vmbindings/vm.rs:171:5
[INFO] [stderr]     |
[INFO] [stderr] 171 |     fn vm_print_stack(vm: *const Vm);
[INFO] [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: method is never used: `print_stack`
[INFO] [stderr]    --> src/vmbindings/vm.rs:211:5
[INFO] [stderr]     |
[INFO] [stderr] 211 |     pub fn print_stack(&self) {
[INFO] [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: method is never used: `gc_disable`
[INFO] [stderr]    --> src/vmbindings/vm.rs:252:5
[INFO] [stderr]     |
[INFO] [stderr] 252 |     pub fn gc_disable(&self) {
[INFO] [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> src/hanayo/cmd.rs:181:17
[INFO] [stderr]     |
[INFO] [stderr] 181 |                 p.stdin.as_mut().unwrap().write_all(s.as_ref().as_bytes());
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(unused_must_use)]` on by default
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/file.rs:72:5
[INFO] [stderr]    |
[INFO] [stderr] 72 |     file.read_to_string(&mut s);
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/file.rs:82:5
[INFO] [stderr]    |
[INFO] [stderr] 82 |     file.read_exact(&mut bytes);
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/proc.rs:15:5
[INFO] [stderr]    |
[INFO] [stderr] 15 | /     p.stdin
[INFO] [stderr] 16 | |         .as_mut()
[INFO] [stderr] 17 | |         .unwrap()
[INFO] [stderr] 18 | |         .write_all(input.as_ref().as_bytes());
[INFO] [stderr]    | |______________________________________________^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: method is never used: `disable`
[INFO] [stderr]    --> src/vmbindings/gc.rs:117:5
[INFO] [stderr]     |
[INFO] [stderr] 117 |     pub fn disable(&mut self) {
[INFO] [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(dead_code)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: method is never used: `get`
[INFO] [stderr]   --> src/vmbindings/interned_string_map.rs:37:5
[INFO] [stderr]    |
[INFO] [stderr] 37 |     pub fn get(&self, idx: u16) -> Option<&Rc<String>> {
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: field is never read: `pointer`
[INFO] [stderr]   --> src/vmbindings/vm.rs:32:5
[INFO] [stderr]    |
[INFO] [stderr] 32 |     pointer: std::num::NonZeroUsize,
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: foreign function is never used: `vm_print_stack`
[INFO] [stderr]    --> src/vmbindings/vm.rs:171:5
[INFO] [stderr]     |
[INFO] [stderr] 171 |     fn vm_print_stack(vm: *const Vm);
[INFO] [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: method is never used: `print_stack`
[INFO] [stderr]    --> src/vmbindings/vm.rs:211:5
[INFO] [stderr]     |
[INFO] [stderr] 211 |     pub fn print_stack(&self) {
[INFO] [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: method is never used: `gc_disable`
[INFO] [stderr]    --> src/vmbindings/vm.rs:252:5
[INFO] [stderr]     |
[INFO] [stderr] 252 |     pub fn gc_disable(&self) {
[INFO] [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]    --> src/hanayo/cmd.rs:181:17
[INFO] [stderr]     |
[INFO] [stderr] 181 |                 p.stdin.as_mut().unwrap().write_all(s.as_ref().as_bytes());
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(unused_must_use)]` on by default
[INFO] [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/file.rs:72:5
[INFO] [stderr]    |
[INFO] [stderr] 72 |     file.read_to_string(&mut s);
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/file.rs:82:5
[INFO] [stderr]    |
[INFO] [stderr] 82 |     file.read_exact(&mut bytes);
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr] warning: unused `std::result::Result` that must be used
[INFO] [stderr]   --> src/hanayo/proc.rs:15:5
[INFO] [stderr]    |
[INFO] [stderr] 15 | /     p.stdin
[INFO] [stderr] 16 | |         .as_mut()
[INFO] [stderr] 17 | |         .unwrap()
[INFO] [stderr] 18 | |         .write_all(input.as_ref().as_bytes());
[INFO] [stderr]    | |______________________________________________^
[INFO] [stderr]    |
[INFO] [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
[INFO] [stderr] 
[INFO] [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 24.03s
[INFO] running `"docker" "inspect" "68a39209636d3087ed5823004ec7245b4558065ecddb2056321f3d9ea774f56e"`
[INFO] running `"docker" "rm" "-f" "68a39209636d3087ed5823004ec7245b4558065ecddb2056321f3d9ea774f56e"`
[INFO] [stdout] 68a39209636d3087ed5823004ec7245b4558065ecddb2056321f3d9ea774f56e
