[INFO] cloning repository https://github.com/gedatsu217/monkey_interpreter
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/gedatsu217/monkey_interpreter" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fgedatsu217%2Fmonkey_interpreter", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fgedatsu217%2Fmonkey_interpreter'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 7ac75bf9e83e9aca70fd2278c30d76831b758b84
[INFO] checking gedatsu217/monkey_interpreter against master#dfd7b8d03fb93d0e03147d28b3be6d93260fa94d for pr-87050
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fgedatsu217%2Fmonkey_interpreter" "/workspace/builds/worker-6/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-6/source'...
[INFO] [stderr] done.
[INFO] validating manifest of git repo https://github.com/gedatsu217/monkey_interpreter on toolchain dfd7b8d03fb93d0e03147d28b3be6d93260fa94d
[INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+dfd7b8d03fb93d0e03147d28b3be6d93260fa94d" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking git repo https://github.com/gedatsu217/monkey_interpreter
[INFO] finished tweaking git repo https://github.com/gedatsu217/monkey_interpreter
[INFO] tweaked toml for git repo https://github.com/gedatsu217/monkey_interpreter written to /workspace/builds/worker-6/source/Cargo.toml
[INFO] crate git repo https://github.com/gedatsu217/monkey_interpreter already has a lockfile, it will not be regenerated
[INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+dfd7b8d03fb93d0e03147d28b3be6d93260fa94d" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "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" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:34b6a614d2c27851fe6cbf88fbd1137609cefab8b10d0615aaeb6fd47975d74e" "/opt/rustwide/cargo-home/bin/cargo" "+dfd7b8d03fb93d0e03147d28b3be6d93260fa94d" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] [stdout] 59a2b47e5b0fa1f57c2418fbbc08164d064320586f67e0cf6bcf7bbb4129e817
[INFO] running `Command { std: "docker" "start" "-a" "59a2b47e5b0fa1f57c2418fbbc08164d064320586f67e0cf6bcf7bbb4129e817", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "59a2b47e5b0fa1f57c2418fbbc08164d064320586f67e0cf6bcf7bbb4129e817", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "59a2b47e5b0fa1f57c2418fbbc08164d064320586f67e0cf6bcf7bbb4129e817", kill_on_drop: false }`
[INFO] [stdout] 59a2b47e5b0fa1f57c2418fbbc08164d064320586f67e0cf6bcf7bbb4129e817
[INFO] running `Command { std: "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" "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" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:34b6a614d2c27851fe6cbf88fbd1137609cefab8b10d0615aaeb6fd47975d74e" "/opt/rustwide/cargo-home/bin/cargo" "+dfd7b8d03fb93d0e03147d28b3be6d93260fa94d" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 93ac4fd42039aa7b6e33d7a0630457ca24b0a913febdb020e1449efca82475cf
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] running `Command { std: "docker" "start" "-a" "93ac4fd42039aa7b6e33d7a0630457ca24b0a913febdb020e1449efca82475cf", kill_on_drop: false }`
[INFO] [stderr]    Compiling ppv-lite86 v0.2.10
[INFO] [stderr]    Compiling unicode-xid v0.2.2
[INFO] [stderr]    Compiling syn v1.0.73
[INFO] [stderr]    Compiling siphasher v0.3.5
[INFO] [stderr]    Compiling libc v0.2.97
[INFO] [stderr]    Compiling proc-macro2 v1.0.27
[INFO] [stderr]    Compiling phf_shared v0.9.0
[INFO] [stderr]    Compiling getrandom v0.2.3
[INFO] [stderr]    Compiling quote v1.0.9
[INFO] [stderr]    Compiling rand_core v0.6.3
[INFO] [stderr]    Compiling rand_chacha v0.3.1
[INFO] [stderr]    Compiling rand v0.8.4
[INFO] [stderr]    Compiling phf_generator v0.9.0
[INFO] [stderr]    Compiling phf_macros v0.9.0
[INFO] [stderr]     Checking phf v0.9.0
[INFO] [stderr]     Checking monkey_interpreter v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: unused import: `token::Token`
[INFO] [stdout]  --> src/parser.rs:1:60
[INFO] [stdout]   |
[INFO] [stdout] 1 | use crate::{ast, ast::Program, lexer, lexer::Lexer, token, token::Token};
[INFO] [stdout]   |                                                            ^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `std::collections::HashMap`
[INFO] [stdout]  --> src/parser.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use std::collections::HashMap;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `repl`, `token`
[INFO] [stdout]  --> src/repl.rs:1:20
[INFO] [stdout]   |
[INFO] [stdout] 1 | use crate::{lexer, repl, token, evaluator, object};
[INFO] [stdout]   |                    ^^^^  ^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `token::Token`
[INFO] [stdout]  --> src/parser.rs:1:60
[INFO] [stdout]   |
[INFO] [stdout] 1 | use crate::{ast, ast::Program, lexer, lexer::Lexer, token, token::Token};
[INFO] [stdout]   |                                                            ^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `std::collections::HashMap`
[INFO] [stdout]  --> src/parser.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use std::collections::HashMap;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `repl`, `token`
[INFO] [stdout]  --> src/repl.rs:1:20
[INFO] [stdout]   |
[INFO] [stdout] 1 | use crate::{lexer, repl, token, evaluator, object};
[INFO] [stdout]   |                    ^^^^  ^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0170]: pattern binding `Nil` is named the same as one of the variants of the type `Statement`
[INFO] [stdout]   --> src/ast.rs:60:13
[INFO] [stdout]    |
[INFO] [stdout] 60 |             Nil => "".to_string(),
[INFO] [stdout]    |             ^^^ help: to match on the variant, qualify the path: `Statement::Nil`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(bindings_with_variant_name)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/ast.rs:52:46
[INFO] [stdout]    |
[INFO] [stdout] 52 |             Statement::ExpressionStatement { Token, Expression } => Expression.into_string(),
[INFO] [stdout]    |                                              ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/ast.rs:53:41
[INFO] [stdout]    |
[INFO] [stdout] 53 |             Statement::BlockStatement { Token, Statements } => {
[INFO] [stdout]    |                                         ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Nil`
[INFO] [stdout]   --> src/ast.rs:60:13
[INFO] [stdout]    |
[INFO] [stdout] 60 |             Nil => "".to_string(),
[INFO] [stdout]    |             ^^^ help: if this is intentional, prefix it with an underscore: `_Nil`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Value`
[INFO] [stdout]    --> src/ast.rs:127:50
[INFO] [stdout]     |
[INFO] [stdout] 127 |             Expression::IntergerLiteral { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                                  ^^^^^ help: try ignoring the field: `Value: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/ast.rs:129:17
[INFO] [stdout]     |
[INFO] [stdout] 129 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/ast.rs:134:17
[INFO] [stdout]     |
[INFO] [stdout] 134 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Value`
[INFO] [stdout]    --> src/ast.rs:147:42
[INFO] [stdout]     |
[INFO] [stdout] 147 |             Expression::Boolean { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                          ^^^^^ help: try ignoring the field: `Value: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/ast.rs:149:17
[INFO] [stdout]     |
[INFO] [stdout] 149 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/ast.rs:177:17
[INFO] [stdout]     |
[INFO] [stdout] 177 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `tok`
[INFO] [stdout]   --> src/token.rs:70:9
[INFO] [stdout]    |
[INFO] [stdout] 70 |     let tok: TokenType;
[INFO] [stdout]    |         ^^^ help: if this is intentional, prefix it with an underscore: `_tok`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:25:45
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ast::Statement::ExpressionStatement{Token, Expression} => evalExpression(Expression),
[INFO] [stdout]    |                                             ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:26:40
[INFO] [stdout]    |
[INFO] [stdout] 26 |         ast::Statement::BlockStatement{Token, Statements} => evalBlockStatement(stmt),
[INFO] [stdout]    |                                        ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Statements`
[INFO] [stdout]   --> src/evaluator.rs:26:47
[INFO] [stdout]    |
[INFO] [stdout] 26 |         ast::Statement::BlockStatement{Token, Statements} => evalBlockStatement(stmt),
[INFO] [stdout]    |                                               ^^^^^^^^^^ help: try ignoring the field: `Statements: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:27:41
[INFO] [stdout]    |
[INFO] [stdout] 27 |         ast::Statement::ReturnStatement{Token, ReturnValue} => {
[INFO] [stdout]    |                                         ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:37:42
[INFO] [stdout]    |
[INFO] [stdout] 37 |         ast::Expression::IntergerLiteral{Token, Value} => object::Object::Integer{Value: *Value},
[INFO] [stdout]    |                                          ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:38:34
[INFO] [stdout]    |
[INFO] [stdout] 38 |         ast::Expression::Boolean{Token, Value} => if *Value {TRUE} else {FALSE},
[INFO] [stdout]    |                                  ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:39:43
[INFO] [stdout]    |
[INFO] [stdout] 39 |         ast::Expression::PrefixExpression{Token, Operator, Right} => {
[INFO] [stdout]    |                                           ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:47:42
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                          ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:52:39
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                       ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Condition`
[INFO] [stdout]   --> src/evaluator.rs:52:46
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                              ^^^^^^^^^ help: try ignoring the field: `Condition: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Consequence`
[INFO] [stdout]   --> src/evaluator.rs:52:57
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                                         ^^^^^^^^^^^ help: try ignoring the field: `Consequence: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Alternative`
[INFO] [stdout]   --> src/evaluator.rs:52:70
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                                                      ^^^^^^^^^^^ help: try ignoring the field: `Alternative: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/evaluator.rs:116:42
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                          ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/evaluator.rs:141:43
[INFO] [stdout]     |
[INFO] [stdout] 141 |     if let ast::Statement::BlockStatement{Token, Statements} = block {
[INFO] [stdout]     |                                           ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `position`
[INFO] [stdout]  --> src/lexer.rs:6:5
[INFO] [stdout]   |
[INFO] [stdout] 6 |     position: i32,
[INFO] [stdout]   |     ^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: constant is never used: `PROMPT`
[INFO] [stdout]  --> src/repl.rs:4:1
[INFO] [stdout]   |
[INFO] [stdout] 4 | const PROMPT: &str = ">> ";
[INFO] [stdout]   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0170]: pattern binding `Nil` is named the same as one of the variants of the type `Statement`
[INFO] [stdout]   --> src/ast.rs:60:13
[INFO] [stdout]    |
[INFO] [stdout] 60 |             Nil => "".to_string(),
[INFO] [stdout]    |             ^^^ help: to match on the variant, qualify the path: `Statement::Nil`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(bindings_with_variant_name)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]  --> src/ast.rs:6:9
[INFO] [stdout]   |
[INFO] [stdout] 6 |         Token: token::Token,
[INFO] [stdout]   |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Name` should have a snake case name
[INFO] [stdout]  --> src/ast.rs:7:9
[INFO] [stdout]   |
[INFO] [stdout] 7 |         Name: Identifier,
[INFO] [stdout]   |         ^^^^ help: convert the identifier to snake case: `name`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]  --> src/ast.rs:8:9
[INFO] [stdout]   |
[INFO] [stdout] 8 |         Value: Expression,
[INFO] [stdout]   |         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:11:9
[INFO] [stdout]    |
[INFO] [stdout] 11 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `ReturnValue` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:12:9
[INFO] [stdout]    |
[INFO] [stdout] 12 |         ReturnValue: Expression,
[INFO] [stdout]    |         ^^^^^^^^^^^ help: convert the identifier to snake case: `return_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:15:9
[INFO] [stdout]    |
[INFO] [stdout] 15 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Expression` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:16:9
[INFO] [stdout]    |
[INFO] [stdout] 16 |         Expression: Expression,
[INFO] [stdout]    |         ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:19:9
[INFO] [stdout]    |
[INFO] [stdout] 19 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Statements` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:20:9
[INFO] [stdout]    |
[INFO] [stdout] 20 |         Statements: Vec<Statement>,
[INFO] [stdout]    |         ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:28:39
[INFO] [stdout]    |
[INFO] [stdout] 28 |             Statement::LetStatement { Token, Name, Value } => write!(
[INFO] [stdout]    |                                       ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Name` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:28:46
[INFO] [stdout]    |
[INFO] [stdout] 28 |             Statement::LetStatement { Token, Name, Value } => write!(
[INFO] [stdout]    |                                              ^^^^ help: convert the identifier to snake case: `name`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:28:52
[INFO] [stdout]    |
[INFO] [stdout] 28 |             Statement::LetStatement { Token, Name, Value } => write!(
[INFO] [stdout]    |                                                    ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:41:39
[INFO] [stdout]    |
[INFO] [stdout] 41 |             Statement::LetStatement { Token, Name, Value } => {
[INFO] [stdout]    |                                       ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Name` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:41:46
[INFO] [stdout]    |
[INFO] [stdout] 41 |             Statement::LetStatement { Token, Name, Value } => {
[INFO] [stdout]    |                                              ^^^^ help: convert the identifier to snake case: `name`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:41:52
[INFO] [stdout]    |
[INFO] [stdout] 41 |             Statement::LetStatement { Token, Name, Value } => {
[INFO] [stdout]    |                                                    ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:49:42
[INFO] [stdout]    |
[INFO] [stdout] 49 |             Statement::ReturnStatement { Token, ReturnValue } => {
[INFO] [stdout]    |                                          ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `ReturnValue` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:49:49
[INFO] [stdout]    |
[INFO] [stdout] 49 |             Statement::ReturnStatement { Token, ReturnValue } => {
[INFO] [stdout]    |                                                 ^^^^^^^^^^^ help: convert the identifier to snake case: `return_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:52:46
[INFO] [stdout]    |
[INFO] [stdout] 52 |             Statement::ExpressionStatement { Token, Expression } => Expression.into_string(),
[INFO] [stdout]    |                                              ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:52:53
[INFO] [stdout]    |
[INFO] [stdout] 52 |             Statement::ExpressionStatement { Token, Expression } => Expression.into_string(),
[INFO] [stdout]    |                                                     ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:53:41
[INFO] [stdout]    |
[INFO] [stdout] 53 |             Statement::BlockStatement { Token, Statements } => {
[INFO] [stdout]    |                                         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:53:48
[INFO] [stdout]    |
[INFO] [stdout] 53 |             Statement::BlockStatement { Token, Statements } => {
[INFO] [stdout]    |                                                ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Nil` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:60:13
[INFO] [stdout]    |
[INFO] [stdout] 60 |             Nil => "".to_string(),
[INFO] [stdout]    |             ^^^ help: convert the identifier to snake case: `nil`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:66:9
[INFO] [stdout]    |
[INFO] [stdout] 66 |     pub Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:67:9
[INFO] [stdout]    |
[INFO] [stdout] 67 |     pub Value: String,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:86:9
[INFO] [stdout]    |
[INFO] [stdout] 86 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:87:9
[INFO] [stdout]    |
[INFO] [stdout] 87 |         Value: i64,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:90:9
[INFO] [stdout]    |
[INFO] [stdout] 90 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Operator` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:91:9
[INFO] [stdout]    |
[INFO] [stdout] 91 |         Operator: String,
[INFO] [stdout]    |         ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Right` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:92:9
[INFO] [stdout]    |
[INFO] [stdout] 92 |         Right: Box<Expression>,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:95:9
[INFO] [stdout]    |
[INFO] [stdout] 95 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Left` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:96:9
[INFO] [stdout]    |
[INFO] [stdout] 96 |         Left: Box<Expression>,
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case: `left`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Operator` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:97:9
[INFO] [stdout]    |
[INFO] [stdout] 97 |         Operator: String,
[INFO] [stdout]    |         ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Right` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:98:9
[INFO] [stdout]    |
[INFO] [stdout] 98 |         Right: Box<Expression>,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:101:9
[INFO] [stdout]     |
[INFO] [stdout] 101 |         Token: token::Token,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:102:9
[INFO] [stdout]     |
[INFO] [stdout] 102 |         Value: bool,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:105:9
[INFO] [stdout]     |
[INFO] [stdout] 105 |         Token: token::Token,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Condition` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:106:9
[INFO] [stdout]     |
[INFO] [stdout] 106 |         Condition: Box<Expression>,
[INFO] [stdout]     |         ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Consequence` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:107:9
[INFO] [stdout]     |
[INFO] [stdout] 107 |         Consequence: Box<Statement>,
[INFO] [stdout]     |         ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Alternative` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:108:9
[INFO] [stdout]     |
[INFO] [stdout] 108 |         Alternative: Box<Statement>,
[INFO] [stdout]     |         ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:111:9
[INFO] [stdout]     |
[INFO] [stdout] 111 |         Token: token::Token,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Parameters` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:112:9
[INFO] [stdout]     |
[INFO] [stdout] 112 |         Parameters: Vec<Expression>,
[INFO] [stdout]     |         ^^^^^^^^^^ help: convert the identifier to snake case: `parameters`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Body` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:113:9
[INFO] [stdout]     |
[INFO] [stdout] 113 |         Body: Box<Statement>,
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case: `body`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:116:9
[INFO] [stdout]     |
[INFO] [stdout] 116 |         Token: token::Token,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Function` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:117:9
[INFO] [stdout]     |
[INFO] [stdout] 117 |         Function: Box<Expression>,
[INFO] [stdout]     |         ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `function`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Arguments` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:118:9
[INFO] [stdout]     |
[INFO] [stdout] 118 |         Arguments: Vec<Expression>,
[INFO] [stdout]     |         ^^^^^^^^^ help: convert the identifier to snake case: `arguments`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Identifier` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:126:36
[INFO] [stdout]     |
[INFO] [stdout] 126 |             Expression::Identifier(Identifier) => Identifier.Value.clone(),
[INFO] [stdout]     |                                    ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `identifier`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:127:43
[INFO] [stdout]     |
[INFO] [stdout] 127 |             Expression::IntergerLiteral { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                           ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:127:50
[INFO] [stdout]     |
[INFO] [stdout] 127 |             Expression::IntergerLiteral { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                                  ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:129:17
[INFO] [stdout]     |
[INFO] [stdout] 129 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:130:17
[INFO] [stdout]     |
[INFO] [stdout] 130 |                 Operator,
[INFO] [stdout]     |                 ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:131:17
[INFO] [stdout]     |
[INFO] [stdout] 131 |                 Right,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:134:17
[INFO] [stdout]     |
[INFO] [stdout] 134 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Left` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:135:17
[INFO] [stdout]     |
[INFO] [stdout] 135 |                 Left,
[INFO] [stdout]     |                 ^^^^ help: convert the identifier to snake case: `left`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:136:17
[INFO] [stdout]     |
[INFO] [stdout] 136 |                 Operator,
[INFO] [stdout]     |                 ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:137:17
[INFO] [stdout]     |
[INFO] [stdout] 137 |                 Right,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:147:35
[INFO] [stdout]     |
[INFO] [stdout] 147 |             Expression::Boolean { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:147:42
[INFO] [stdout]     |
[INFO] [stdout] 147 |             Expression::Boolean { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                          ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:149:17
[INFO] [stdout]     |
[INFO] [stdout] 149 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Condition` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:150:17
[INFO] [stdout]     |
[INFO] [stdout] 150 |                 Condition,
[INFO] [stdout]     |                 ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Consequence` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:151:17
[INFO] [stdout]     |
[INFO] [stdout] 151 |                 Consequence,
[INFO] [stdout]     |                 ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Alternative` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:152:17
[INFO] [stdout]     |
[INFO] [stdout] 152 |                 Alternative,
[INFO] [stdout]     |                 ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:166:17
[INFO] [stdout]     |
[INFO] [stdout] 166 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Parameters` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:167:17
[INFO] [stdout]     |
[INFO] [stdout] 167 |                 Parameters,
[INFO] [stdout]     |                 ^^^^^^^^^^ help: convert the identifier to snake case: `parameters`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Body` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:168:17
[INFO] [stdout]     |
[INFO] [stdout] 168 |                 Body,
[INFO] [stdout]     |                 ^^^^ help: convert the identifier to snake case: `body`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:177:17
[INFO] [stdout]     |
[INFO] [stdout] 177 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Function` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:178:17
[INFO] [stdout]     |
[INFO] [stdout] 178 |                 Function,
[INFO] [stdout]     |                 ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `function`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Arguments` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:179:17
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 Arguments,
[INFO] [stdout]     |                 ^^^^^^^^^ help: convert the identifier to snake case: `arguments`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Statements` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:198:9
[INFO] [stdout]     |
[INFO] [stdout] 198 |     pub Statements: Vec<Statement>,
[INFO] [stdout]     |         ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `readPosition` should have a snake case name
[INFO] [stdout]  --> src/lexer.rs:7:5
[INFO] [stdout]   |
[INFO] [stdout] 7 |     readPosition: i32,
[INFO] [stdout]   |     ^^^^^^^^^^^^ help: convert the identifier to snake case: `read_position`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `New` should have a snake case name
[INFO] [stdout]   --> src/lexer.rs:11:8
[INFO] [stdout]    |
[INFO] [stdout] 11 | pub fn New(input: String) -> Lexer {
[INFO] [stdout]    |        ^^^ help: convert the identifier to snake case: `new`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `readChar` should have a snake case name
[INFO] [stdout]   --> src/lexer.rs:23:8
[INFO] [stdout]    |
[INFO] [stdout] 23 |     fn readChar(&mut self) {
[INFO] [stdout]    |        ^^^^^^^^ help: convert the identifier to snake case: `read_char`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `NextToken` should have a snake case name
[INFO] [stdout]   --> src/lexer.rs:40:12
[INFO] [stdout]    |
[INFO] [stdout] 40 |     pub fn NextToken(&mut self) -> Token {
[INFO] [stdout]    |            ^^^^^^^^^ help: convert the identifier to snake case: `next_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `readIdentifier` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:132:8
[INFO] [stdout]     |
[INFO] [stdout] 132 |     fn readIdentifier(&mut self) -> String {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `read_identifier`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `readNumber` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:141:8
[INFO] [stdout]     |
[INFO] [stdout] 141 |     fn readNumber(&mut self) -> String {
[INFO] [stdout]     |        ^^^^^^^^^^ help: convert the identifier to snake case: `read_number`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `skipWhitespace` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:150:8
[INFO] [stdout]     |
[INFO] [stdout] 150 |     fn skipWhitespace(&mut self) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `skip_whitespace`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `peekChar` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:161:8
[INFO] [stdout]     |
[INFO] [stdout] 161 |     fn peekChar(&mut self) -> Option<String> {
[INFO] [stdout]     |        ^^^^^^^^ help: convert the identifier to snake case: `peek_char`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `newToken` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:176:8
[INFO] [stdout]     |
[INFO] [stdout] 176 | pub fn newToken(tokenType: token::TokenType, ch: &Option<String>) -> Token {
[INFO] [stdout]     |        ^^^^^^^^ help: convert the identifier to snake case: `new_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `tokenType` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:176:17
[INFO] [stdout]     |
[INFO] [stdout] 176 | pub fn newToken(tokenType: token::TokenType, ch: &Option<String>) -> Token {
[INFO] [stdout]     |                 ^^^^^^^^^ help: convert the identifier to snake case: `token_type`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `isLetter` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:183:4
[INFO] [stdout]     |
[INFO] [stdout] 183 | fn isLetter(s: &Option<String>) -> bool {
[INFO] [stdout]     |    ^^^^^^^^ help: convert the identifier to snake case: `is_letter`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `isDigit` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:193:4
[INFO] [stdout]     |
[INFO] [stdout] 193 | fn isDigit(s: &Option<String>) -> bool {
[INFO] [stdout]     |    ^^^^^^^ help: convert the identifier to snake case: `is_digit`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: static variable `precedences` should have an upper case name
[INFO] [stdout]   --> src/parser.rs:13:8
[INFO] [stdout]    |
[INFO] [stdout] 13 | static precedences: phf::Map<&'static str, i32> = phf_map! {
[INFO] [stdout]    |        ^^^^^^^^^^^ help: convert the identifier to upper case: `PRECEDENCES`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(non_upper_case_globals)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `curToken` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:27:5
[INFO] [stdout]    |
[INFO] [stdout] 27 |     curToken: token::Token,
[INFO] [stdout]    |     ^^^^^^^^ help: convert the identifier to snake case: `cur_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `peekToken` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:28:5
[INFO] [stdout]    |
[INFO] [stdout] 28 |     peekToken: token::Token,
[INFO] [stdout]    |     ^^^^^^^^^ help: convert the identifier to snake case: `peek_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `New` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:33:12
[INFO] [stdout]    |
[INFO] [stdout] 33 |     pub fn New(self) -> Parser {
[INFO] [stdout]    |            ^^^ help: convert the identifier to snake case: `new`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `nextToken` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:47:8
[INFO] [stdout]    |
[INFO] [stdout] 47 |     fn nextToken(&mut self) {
[INFO] [stdout]    |        ^^^^^^^^^ help: convert the identifier to snake case: `next_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `ParseProgram` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:52:12
[INFO] [stdout]    |
[INFO] [stdout] 52 |     pub fn ParseProgram(&mut self) -> Program {
[INFO] [stdout]    |            ^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_program`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseStatement` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:64:8
[INFO] [stdout]    |
[INFO] [stdout] 64 |     fn parseStatement(&mut self) -> Option<ast::Statement> {
[INFO] [stdout]    |        ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseLetStatement` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:72:8
[INFO] [stdout]    |
[INFO] [stdout] 72 |     fn parseLetStatement(&mut self) -> Option<ast::Statement> {
[INFO] [stdout]    |        ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_let_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `curTokenIs` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:102:8
[INFO] [stdout]     |
[INFO] [stdout] 102 |     fn curTokenIs(&self, t: token::TokenType) -> bool {
[INFO] [stdout]     |        ^^^^^^^^^^ help: convert the identifier to snake case: `cur_token_is`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `peekTokenIs` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:106:8
[INFO] [stdout]     |
[INFO] [stdout] 106 |     fn peekTokenIs(&self, t: token::TokenType) -> bool {
[INFO] [stdout]     |        ^^^^^^^^^^^ help: convert the identifier to snake case: `peek_token_is`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `expectPeek` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:110:8
[INFO] [stdout]     |
[INFO] [stdout] 110 |     fn expectPeek(&mut self, t: token::TokenType) -> bool {
[INFO] [stdout]     |        ^^^^^^^^^^ help: convert the identifier to snake case: `expect_peek`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/ast.rs:52:46
[INFO] [stdout]    |
[INFO] [stdout] 52 |             Statement::ExpressionStatement { Token, Expression } => Expression.into_string(),
[INFO] [stdout]    |                                              ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `Errors` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:120:12
[INFO] [stdout]     |
[INFO] [stdout] 120 |     pub fn Errors(&self) -> &Vec<String> {
[INFO] [stdout]     |            ^^^^^^ help: convert the identifier to snake case: `errors`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/ast.rs:53:41
[INFO] [stdout]    |
[INFO] [stdout] 53 |             Statement::BlockStatement { Token, Statements } => {
[INFO] [stdout]    |                                         ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `peekError` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:124:8
[INFO] [stdout]     |
[INFO] [stdout] 124 |     fn peekError(&mut self, t: token::TokenType) {
[INFO] [stdout]     |        ^^^^^^^^^ help: convert the identifier to snake case: `peek_error`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Nil`
[INFO] [stdout]   --> src/ast.rs:60:13
[INFO] [stdout]    |
[INFO] [stdout] 60 |             Nil => "".to_string(),
[INFO] [stdout]    |             ^^^ help: if this is intentional, prefix it with an underscore: `_Nil`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `checkParserErrors` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:132:12
[INFO] [stdout]     |
[INFO] [stdout] 132 |     pub fn checkParserErrors(&self) {
[INFO] [stdout]     |            ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `check_parser_errors`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseReturnStatement` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:144:8
[INFO] [stdout]     |
[INFO] [stdout] 144 |     fn parseReturnStatement(&mut self) -> Option<ast::Statement> {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_return_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Value`
[INFO] [stdout]    --> src/ast.rs:127:50
[INFO] [stdout]     |
[INFO] [stdout] 127 |             Expression::IntergerLiteral { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                                  ^^^^^ help: try ignoring the field: `Value: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/ast.rs:129:17
[INFO] [stdout]     |
[INFO] [stdout] 129 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseExpressionStatement` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:159:8
[INFO] [stdout]     |
[INFO] [stdout] 159 |     fn parseExpressionStatement(&mut self) -> Option<ast::Statement> {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_expression_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/ast.rs:134:17
[INFO] [stdout]     |
[INFO] [stdout] 134 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:177:8
[INFO] [stdout]     |
[INFO] [stdout] 177 |     fn parseExpression(&mut self, precedence: i32) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Value`
[INFO] [stdout]    --> src/ast.rs:147:42
[INFO] [stdout]     |
[INFO] [stdout] 147 |             Expression::Boolean { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                          ^^^^^ help: try ignoring the field: `Value: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseIntergerLiteral` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:243:8
[INFO] [stdout]     |
[INFO] [stdout] 243 |     fn parseIntergerLiteral(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_interger_literal`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/ast.rs:149:17
[INFO] [stdout]     |
[INFO] [stdout] 149 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/ast.rs:177:17
[INFO] [stdout]     |
[INFO] [stdout] 177 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parsePrefixExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:259:8
[INFO] [stdout]     |
[INFO] [stdout] 259 |     fn parsePrefixExpression(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_prefix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `peekPrecedence` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:270:8
[INFO] [stdout]     |
[INFO] [stdout] 270 |     fn peekPrecedence(&self) -> i32 {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `peek_precedence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `curPrecedence` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:278:8
[INFO] [stdout]     |
[INFO] [stdout] 278 |     fn curPrecedence(&self) -> i32 {
[INFO] [stdout]     |        ^^^^^^^^^^^^^ help: convert the identifier to snake case: `cur_precedence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseInfixExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:286:8
[INFO] [stdout]     |
[INFO] [stdout] 286 |     fn parseInfixExpression(&mut self, left: ast::Expression) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_infix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseBoolean` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:299:8
[INFO] [stdout]     |
[INFO] [stdout] 299 |     fn parseBoolean(&self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_boolean`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseGroupedExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:306:8
[INFO] [stdout]     |
[INFO] [stdout] 306 |     fn parseGroupedExpression(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_grouped_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `tok`
[INFO] [stdout]   --> src/token.rs:70:9
[INFO] [stdout]    |
[INFO] [stdout] 70 |     let tok: TokenType;
[INFO] [stdout]    |         ^^^ help: if this is intentional, prefix it with an underscore: `_tok`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseIfExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:317:8
[INFO] [stdout]     |
[INFO] [stdout] 317 |     fn parseIfExpression(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_if_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseBlockStatement` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:354:8
[INFO] [stdout]     |
[INFO] [stdout] 354 |     fn parseBlockStatement(&mut self) -> ast::Statement {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_block_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:25:45
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ast::Statement::ExpressionStatement{Token, Expression} => evalExpression(Expression),
[INFO] [stdout]    |                                             ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseFunctionLiteral` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:374:8
[INFO] [stdout]     |
[INFO] [stdout] 374 |     fn parseFunctionLiteral(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_function_literal`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:26:40
[INFO] [stdout]    |
[INFO] [stdout] 26 |         ast::Statement::BlockStatement{Token, Statements} => evalBlockStatement(stmt),
[INFO] [stdout]    |                                        ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Statements`
[INFO] [stdout]   --> src/evaluator.rs:26:47
[INFO] [stdout]    |
[INFO] [stdout] 26 |         ast::Statement::BlockStatement{Token, Statements} => evalBlockStatement(stmt),
[INFO] [stdout]    |                                               ^^^^^^^^^^ help: try ignoring the field: `Statements: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseFunctionParameters` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:397:8
[INFO] [stdout]     |
[INFO] [stdout] 397 |     fn parseFunctionParameters(&mut self) -> Option<Vec<ast::Expression>> {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_function_parameters`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:27:41
[INFO] [stdout]    |
[INFO] [stdout] 27 |         ast::Statement::ReturnStatement{Token, ReturnValue} => {
[INFO] [stdout]    |                                         ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseCallExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:430:8
[INFO] [stdout]     |
[INFO] [stdout] 430 |     fn parseCallExpression(&mut self, function: ast::Expression) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_call_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:37:42
[INFO] [stdout]    |
[INFO] [stdout] 37 |         ast::Expression::IntergerLiteral{Token, Value} => object::Object::Integer{Value: *Value},
[INFO] [stdout]    |                                          ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseCallArguments` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:441:8
[INFO] [stdout]     |
[INFO] [stdout] 441 |     fn parseCallArguments(&mut self) -> Option<Vec<ast::Expression>> {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_call_arguments`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:38:34
[INFO] [stdout]    |
[INFO] [stdout] 38 |         ast::Expression::Boolean{Token, Value} => if *Value {TRUE} else {FALSE},
[INFO] [stdout]    |                                  ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:39:43
[INFO] [stdout]    |
[INFO] [stdout] 39 |         ast::Expression::PrefixExpression{Token, Operator, Right} => {
[INFO] [stdout]    |                                           ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `Start` should have a snake case name
[INFO] [stdout]  --> src/repl.rs:6:8
[INFO] [stdout]   |
[INFO] [stdout] 6 | pub fn Start() {
[INFO] [stdout]   |        ^^^^^ help: convert the identifier to snake case (notice the capitalization): `start`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:47:42
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                          ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `printParserErrors` should have a snake case name
[INFO] [stdout]   --> src/repl.rs:27:4
[INFO] [stdout]    |
[INFO] [stdout] 27 | fn printParserErrors(errors: &Vec<String>) {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `print_parser_errors`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> src/evaluator.rs:52:39
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                       ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Condition`
[INFO] [stdout]   --> src/evaluator.rs:52:46
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                              ^^^^^^^^^ help: try ignoring the field: `Condition: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Consequence`
[INFO] [stdout]   --> src/evaluator.rs:52:57
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                                         ^^^^^^^^^^^ help: try ignoring the field: `Consequence: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Type` should have a snake case name
[INFO] [stdout]   --> src/token.rs:41:9
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub Type: TokenType,
[INFO] [stdout]    |         ^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: rename the identifier or convert it to a snake case raw identifier
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub r#type: TokenType,
[INFO] [stdout]    |         ^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Alternative`
[INFO] [stdout]   --> src/evaluator.rs:52:70
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                                                      ^^^^^^^^^^^ help: try ignoring the field: `Alternative: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Literal` should have a snake case name
[INFO] [stdout]   --> src/token.rs:42:9
[INFO] [stdout]    |
[INFO] [stdout] 42 |     pub Literal: String,
[INFO] [stdout]    |         ^^^^^^^ help: convert the identifier to snake case: `literal`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/evaluator.rs:116:42
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                          ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `LookupIdent` should have a snake case name
[INFO] [stdout]   --> src/token.rs:60:8
[INFO] [stdout]    |
[INFO] [stdout] 60 | pub fn LookupIdent(ident: &String) -> TokenType {
[INFO] [stdout]    |        ^^^^^^^^^^^ help: convert the identifier to snake case: `lookup_ident`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> src/evaluator.rs:141:43
[INFO] [stdout]     |
[INFO] [stdout] 141 |     if let ast::Statement::BlockStatement{Token, Statements} = block {
[INFO] [stdout]     |                                           ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/object.rs:12:13
[INFO] [stdout]    |
[INFO] [stdout] 12 |     Integer{Value: i64},
[INFO] [stdout]    |             ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/object.rs:13:13
[INFO] [stdout]    |
[INFO] [stdout] 13 |     Boolean{Value: bool},
[INFO] [stdout]    |             ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/object.rs:14:17
[INFO] [stdout]    |
[INFO] [stdout] 14 |     ReturnValue{Value: Box<Object>},
[INFO] [stdout]    |                 ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `Type` should have a snake case name
[INFO] [stdout]   --> src/object.rs:19:12
[INFO] [stdout]    |
[INFO] [stdout] 19 |     pub fn Type(&self) -> ObjectType {
[INFO] [stdout]    |            ^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: rename the identifier or convert it to a snake case raw identifier
[INFO] [stdout]    |
[INFO] [stdout] 19 |     pub fn r#type(&self) -> ObjectType {
[INFO] [stdout]    |            ^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `Inspect` should have a snake case name
[INFO] [stdout]   --> src/object.rs:28:12
[INFO] [stdout]    |
[INFO] [stdout] 28 |     pub fn Inspect(&self) -> String {
[INFO] [stdout]    |            ^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `inspect`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `Eval` should have a snake case name
[INFO] [stdout]  --> src/evaluator.rs:7:8
[INFO] [stdout]   |
[INFO] [stdout] 7 | pub fn Eval(node: ast::Program) -> object::Object {
[INFO] [stdout]   |        ^^^^ help: convert the identifier to snake case: `eval`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalStatements` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:11:4
[INFO] [stdout]    |
[INFO] [stdout] 11 | fn evalStatements(stmts: &Vec<ast::Statement>) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalStatement` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:23:4
[INFO] [stdout]    |
[INFO] [stdout] 23 | fn evalStatement(stmt: &ast::Statement) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:25:45
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ast::Statement::ExpressionStatement{Token, Expression} => evalExpression(Expression),
[INFO] [stdout]    |                                             ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:25:52
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ast::Statement::ExpressionStatement{Token, Expression} => evalExpression(Expression),
[INFO] [stdout]    |                                                    ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:26:40
[INFO] [stdout]    |
[INFO] [stdout] 26 |         ast::Statement::BlockStatement{Token, Statements} => evalBlockStatement(stmt),
[INFO] [stdout]    |                                        ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:26:47
[INFO] [stdout]    |
[INFO] [stdout] 26 |         ast::Statement::BlockStatement{Token, Statements} => evalBlockStatement(stmt),
[INFO] [stdout]    |                                               ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:27:41
[INFO] [stdout]    |
[INFO] [stdout] 27 |         ast::Statement::ReturnStatement{Token, ReturnValue} => {
[INFO] [stdout]    |                                         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `ReturnValue` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:27:48
[INFO] [stdout]    |
[INFO] [stdout] 27 |         ast::Statement::ReturnStatement{Token, ReturnValue} => {
[INFO] [stdout]    |                                                ^^^^^^^^^^^ help: convert the identifier to snake case: `return_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:35:4
[INFO] [stdout]    |
[INFO] [stdout] 35 | fn evalExpression(exp: &ast::Expression) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:37:42
[INFO] [stdout]    |
[INFO] [stdout] 37 |         ast::Expression::IntergerLiteral{Token, Value} => object::Object::Integer{Value: *Value},
[INFO] [stdout]    |                                          ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:37:49
[INFO] [stdout]    |
[INFO] [stdout] 37 |         ast::Expression::IntergerLiteral{Token, Value} => object::Object::Integer{Value: *Value},
[INFO] [stdout]    |                                                 ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:38:34
[INFO] [stdout]    |
[INFO] [stdout] 38 |         ast::Expression::Boolean{Token, Value} => if *Value {TRUE} else {FALSE},
[INFO] [stdout]    |                                  ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:38:41
[INFO] [stdout]    |
[INFO] [stdout] 38 |         ast::Expression::Boolean{Token, Value} => if *Value {TRUE} else {FALSE},
[INFO] [stdout]    |                                         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:39:43
[INFO] [stdout]    |
[INFO] [stdout] 39 |         ast::Expression::PrefixExpression{Token, Operator, Right} => {
[INFO] [stdout]    |                                           ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:39:50
[INFO] [stdout]    |
[INFO] [stdout] 39 |         ast::Expression::PrefixExpression{Token, Operator, Right} => {
[INFO] [stdout]    |                                                  ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:39:60
[INFO] [stdout]    |
[INFO] [stdout] 39 |         ast::Expression::PrefixExpression{Token, Operator, Right} => {
[INFO] [stdout]    |                                                            ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:47:42
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                          ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Left` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:47:49
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                                 ^^^^ help: convert the identifier to snake case: `left`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:47:55
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                                       ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:47:65
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                                                 ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:52:39
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                       ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Condition` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:52:46
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                              ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Consequence` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:52:57
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                                         ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Alternative` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:52:70
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                                                      ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalPrefixExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:59:4
[INFO] [stdout]    |
[INFO] [stdout] 59 | fn evalPrefixExpression(operator: &String, right: object::Object) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_prefix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalBangOperatorExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:67:4
[INFO] [stdout]    |
[INFO] [stdout] 67 | fn evalBangOperatorExpression(right: object::Object) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_bang_operator_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalMinusPrefixOperatorExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:76:4
[INFO] [stdout]    |
[INFO] [stdout] 76 | fn evalMinusPrefixOperatorExpression(right: object::Object) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_minus_prefix_operator_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalInfixExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:84:4
[INFO] [stdout]    |
[INFO] [stdout] 84 | fn evalInfixExpression(operator: &String, left: object::Object, right: object::Object) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_infix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalIntegerInfixExpression` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:101:4
[INFO] [stdout]     |
[INFO] [stdout] 101 | fn evalIntegerInfixExpression(operator: &String, left: i64, right:i64) -> object::Object {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_integer_infix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalIfExpression` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:115:4
[INFO] [stdout]     |
[INFO] [stdout] 115 | fn evalIfExpression(ie: &ast::Expression) -> object::Object {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_if_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:116:42
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                          ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Condition` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:116:49
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                                 ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Consequence` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:116:60
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Alternative` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:116:73
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `isTruthy` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:131:4
[INFO] [stdout]     |
[INFO] [stdout] 131 | fn isTruthy(obj: &object::Object) -> bool {
[INFO] [stdout]     |    ^^^^^^^^ help: convert the identifier to snake case: `is_truthy`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalBlockStatement` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:140:4
[INFO] [stdout]     |
[INFO] [stdout] 140 | fn evalBlockStatement(block: &ast::Statement) -> object::Object {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_block_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:141:43
[INFO] [stdout]     |
[INFO] [stdout] 141 |     if let ast::Statement::BlockStatement{Token, Statements} = block {
[INFO] [stdout]     |                                           ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:141:50
[INFO] [stdout]     |
[INFO] [stdout] 141 |     if let ast::Statement::BlockStatement{Token, Statements} = block {
[INFO] [stdout]     |                                                  ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 189 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0170`.
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `position`
[INFO] [stdout]  --> src/lexer.rs:6:5
[INFO] [stdout]   |
[INFO] [stdout] 6 |     position: i32,
[INFO] [stdout]   |     ^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: constant is never used: `PROMPT`
[INFO] [stdout]  --> src/repl.rs:4:1
[INFO] [stdout]   |
[INFO] [stdout] 4 | const PROMPT: &str = ">> ";
[INFO] [stdout]   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]  --> src/ast.rs:6:9
[INFO] [stdout]   |
[INFO] [stdout] 6 |         Token: token::Token,
[INFO] [stdout]   |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Name` should have a snake case name
[INFO] [stdout]  --> src/ast.rs:7:9
[INFO] [stdout]   |
[INFO] [stdout] 7 |         Name: Identifier,
[INFO] [stdout]   |         ^^^^ help: convert the identifier to snake case: `name`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]  --> src/ast.rs:8:9
[INFO] [stdout]   |
[INFO] [stdout] 8 |         Value: Expression,
[INFO] [stdout]   |         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:11:9
[INFO] [stdout]    |
[INFO] [stdout] 11 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `ReturnValue` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:12:9
[INFO] [stdout]    |
[INFO] [stdout] 12 |         ReturnValue: Expression,
[INFO] [stdout]    |         ^^^^^^^^^^^ help: convert the identifier to snake case: `return_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:15:9
[INFO] [stdout]    |
[INFO] [stdout] 15 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Expression` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:16:9
[INFO] [stdout]    |
[INFO] [stdout] 16 |         Expression: Expression,
[INFO] [stdout]    |         ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:19:9
[INFO] [stdout]    |
[INFO] [stdout] 19 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Statements` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:20:9
[INFO] [stdout]    |
[INFO] [stdout] 20 |         Statements: Vec<Statement>,
[INFO] [stdout]    |         ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:28:39
[INFO] [stdout]    |
[INFO] [stdout] 28 |             Statement::LetStatement { Token, Name, Value } => write!(
[INFO] [stdout]    |                                       ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Name` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:28:46
[INFO] [stdout]    |
[INFO] [stdout] 28 |             Statement::LetStatement { Token, Name, Value } => write!(
[INFO] [stdout]    |                                              ^^^^ help: convert the identifier to snake case: `name`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:28:52
[INFO] [stdout]    |
[INFO] [stdout] 28 |             Statement::LetStatement { Token, Name, Value } => write!(
[INFO] [stdout]    |                                                    ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:41:39
[INFO] [stdout]    |
[INFO] [stdout] 41 |             Statement::LetStatement { Token, Name, Value } => {
[INFO] [stdout]    |                                       ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Name` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:41:46
[INFO] [stdout]    |
[INFO] [stdout] 41 |             Statement::LetStatement { Token, Name, Value } => {
[INFO] [stdout]    |                                              ^^^^ help: convert the identifier to snake case: `name`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:41:52
[INFO] [stdout]    |
[INFO] [stdout] 41 |             Statement::LetStatement { Token, Name, Value } => {
[INFO] [stdout]    |                                                    ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:49:42
[INFO] [stdout]    |
[INFO] [stdout] 49 |             Statement::ReturnStatement { Token, ReturnValue } => {
[INFO] [stdout]    |                                          ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `ReturnValue` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:49:49
[INFO] [stdout]    |
[INFO] [stdout] 49 |             Statement::ReturnStatement { Token, ReturnValue } => {
[INFO] [stdout]    |                                                 ^^^^^^^^^^^ help: convert the identifier to snake case: `return_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:52:46
[INFO] [stdout]    |
[INFO] [stdout] 52 |             Statement::ExpressionStatement { Token, Expression } => Expression.into_string(),
[INFO] [stdout]    |                                              ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:52:53
[INFO] [stdout]    |
[INFO] [stdout] 52 |             Statement::ExpressionStatement { Token, Expression } => Expression.into_string(),
[INFO] [stdout]    |                                                     ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:53:41
[INFO] [stdout]    |
[INFO] [stdout] 53 |             Statement::BlockStatement { Token, Statements } => {
[INFO] [stdout]    |                                         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:53:48
[INFO] [stdout]    |
[INFO] [stdout] 53 |             Statement::BlockStatement { Token, Statements } => {
[INFO] [stdout]    |                                                ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Nil` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:60:13
[INFO] [stdout]    |
[INFO] [stdout] 60 |             Nil => "".to_string(),
[INFO] [stdout]    |             ^^^ help: convert the identifier to snake case: `nil`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:66:9
[INFO] [stdout]    |
[INFO] [stdout] 66 |     pub Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:67:9
[INFO] [stdout]    |
[INFO] [stdout] 67 |     pub Value: String,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:86:9
[INFO] [stdout]    |
[INFO] [stdout] 86 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:87:9
[INFO] [stdout]    |
[INFO] [stdout] 87 |         Value: i64,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:90:9
[INFO] [stdout]    |
[INFO] [stdout] 90 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Operator` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:91:9
[INFO] [stdout]    |
[INFO] [stdout] 91 |         Operator: String,
[INFO] [stdout]    |         ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Right` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:92:9
[INFO] [stdout]    |
[INFO] [stdout] 92 |         Right: Box<Expression>,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:95:9
[INFO] [stdout]    |
[INFO] [stdout] 95 |         Token: token::Token,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Left` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:96:9
[INFO] [stdout]    |
[INFO] [stdout] 96 |         Left: Box<Expression>,
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case: `left`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Operator` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:97:9
[INFO] [stdout]    |
[INFO] [stdout] 97 |         Operator: String,
[INFO] [stdout]    |         ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Right` should have a snake case name
[INFO] [stdout]   --> src/ast.rs:98:9
[INFO] [stdout]    |
[INFO] [stdout] 98 |         Right: Box<Expression>,
[INFO] [stdout]    |         ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:101:9
[INFO] [stdout]     |
[INFO] [stdout] 101 |         Token: token::Token,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:102:9
[INFO] [stdout]     |
[INFO] [stdout] 102 |         Value: bool,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:105:9
[INFO] [stdout]     |
[INFO] [stdout] 105 |         Token: token::Token,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Condition` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:106:9
[INFO] [stdout]     |
[INFO] [stdout] 106 |         Condition: Box<Expression>,
[INFO] [stdout]     |         ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Consequence` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:107:9
[INFO] [stdout]     |
[INFO] [stdout] 107 |         Consequence: Box<Statement>,
[INFO] [stdout]     |         ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Alternative` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:108:9
[INFO] [stdout]     |
[INFO] [stdout] 108 |         Alternative: Box<Statement>,
[INFO] [stdout]     |         ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:111:9
[INFO] [stdout]     |
[INFO] [stdout] 111 |         Token: token::Token,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Parameters` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:112:9
[INFO] [stdout]     |
[INFO] [stdout] 112 |         Parameters: Vec<Expression>,
[INFO] [stdout]     |         ^^^^^^^^^^ help: convert the identifier to snake case: `parameters`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Body` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:113:9
[INFO] [stdout]     |
[INFO] [stdout] 113 |         Body: Box<Statement>,
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case: `body`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:116:9
[INFO] [stdout]     |
[INFO] [stdout] 116 |         Token: token::Token,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Function` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:117:9
[INFO] [stdout]     |
[INFO] [stdout] 117 |         Function: Box<Expression>,
[INFO] [stdout]     |         ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `function`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Arguments` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:118:9
[INFO] [stdout]     |
[INFO] [stdout] 118 |         Arguments: Vec<Expression>,
[INFO] [stdout]     |         ^^^^^^^^^ help: convert the identifier to snake case: `arguments`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Identifier` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:126:36
[INFO] [stdout]     |
[INFO] [stdout] 126 |             Expression::Identifier(Identifier) => Identifier.Value.clone(),
[INFO] [stdout]     |                                    ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `identifier`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:127:43
[INFO] [stdout]     |
[INFO] [stdout] 127 |             Expression::IntergerLiteral { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                           ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:127:50
[INFO] [stdout]     |
[INFO] [stdout] 127 |             Expression::IntergerLiteral { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                                  ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:129:17
[INFO] [stdout]     |
[INFO] [stdout] 129 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:130:17
[INFO] [stdout]     |
[INFO] [stdout] 130 |                 Operator,
[INFO] [stdout]     |                 ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:131:17
[INFO] [stdout]     |
[INFO] [stdout] 131 |                 Right,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:134:17
[INFO] [stdout]     |
[INFO] [stdout] 134 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Left` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:135:17
[INFO] [stdout]     |
[INFO] [stdout] 135 |                 Left,
[INFO] [stdout]     |                 ^^^^ help: convert the identifier to snake case: `left`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:136:17
[INFO] [stdout]     |
[INFO] [stdout] 136 |                 Operator,
[INFO] [stdout]     |                 ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:137:17
[INFO] [stdout]     |
[INFO] [stdout] 137 |                 Right,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:147:35
[INFO] [stdout]     |
[INFO] [stdout] 147 |             Expression::Boolean { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:147:42
[INFO] [stdout]     |
[INFO] [stdout] 147 |             Expression::Boolean { Token, Value } => Token.Literal.clone(),
[INFO] [stdout]     |                                          ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:149:17
[INFO] [stdout]     |
[INFO] [stdout] 149 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Condition` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:150:17
[INFO] [stdout]     |
[INFO] [stdout] 150 |                 Condition,
[INFO] [stdout]     |                 ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Consequence` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:151:17
[INFO] [stdout]     |
[INFO] [stdout] 151 |                 Consequence,
[INFO] [stdout]     |                 ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Alternative` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:152:17
[INFO] [stdout]     |
[INFO] [stdout] 152 |                 Alternative,
[INFO] [stdout]     |                 ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:166:17
[INFO] [stdout]     |
[INFO] [stdout] 166 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Parameters` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:167:17
[INFO] [stdout]     |
[INFO] [stdout] 167 |                 Parameters,
[INFO] [stdout]     |                 ^^^^^^^^^^ help: convert the identifier to snake case: `parameters`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Body` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:168:17
[INFO] [stdout]     |
[INFO] [stdout] 168 |                 Body,
[INFO] [stdout]     |                 ^^^^ help: convert the identifier to snake case: `body`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:177:17
[INFO] [stdout]     |
[INFO] [stdout] 177 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Function` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:178:17
[INFO] [stdout]     |
[INFO] [stdout] 178 |                 Function,
[INFO] [stdout]     |                 ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `function`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Arguments` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:179:17
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 Arguments,
[INFO] [stdout]     |                 ^^^^^^^^^ help: convert the identifier to snake case: `arguments`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Statements` should have a snake case name
[INFO] [stdout]    --> src/ast.rs:198:9
[INFO] [stdout]     |
[INFO] [stdout] 198 |     pub Statements: Vec<Statement>,
[INFO] [stdout]     |         ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `readPosition` should have a snake case name
[INFO] [stdout]  --> src/lexer.rs:7:5
[INFO] [stdout]   |
[INFO] [stdout] 7 |     readPosition: i32,
[INFO] [stdout]   |     ^^^^^^^^^^^^ help: convert the identifier to snake case: `read_position`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `New` should have a snake case name
[INFO] [stdout]   --> src/lexer.rs:11:8
[INFO] [stdout]    |
[INFO] [stdout] 11 | pub fn New(input: String) -> Lexer {
[INFO] [stdout]    |        ^^^ help: convert the identifier to snake case: `new`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `readChar` should have a snake case name
[INFO] [stdout]   --> src/lexer.rs:23:8
[INFO] [stdout]    |
[INFO] [stdout] 23 |     fn readChar(&mut self) {
[INFO] [stdout]    |        ^^^^^^^^ help: convert the identifier to snake case: `read_char`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `NextToken` should have a snake case name
[INFO] [stdout]   --> src/lexer.rs:40:12
[INFO] [stdout]    |
[INFO] [stdout] 40 |     pub fn NextToken(&mut self) -> Token {
[INFO] [stdout]    |            ^^^^^^^^^ help: convert the identifier to snake case: `next_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `readIdentifier` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:132:8
[INFO] [stdout]     |
[INFO] [stdout] 132 |     fn readIdentifier(&mut self) -> String {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `read_identifier`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `readNumber` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:141:8
[INFO] [stdout]     |
[INFO] [stdout] 141 |     fn readNumber(&mut self) -> String {
[INFO] [stdout]     |        ^^^^^^^^^^ help: convert the identifier to snake case: `read_number`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `skipWhitespace` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:150:8
[INFO] [stdout]     |
[INFO] [stdout] 150 |     fn skipWhitespace(&mut self) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `skip_whitespace`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `peekChar` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:161:8
[INFO] [stdout]     |
[INFO] [stdout] 161 |     fn peekChar(&mut self) -> Option<String> {
[INFO] [stdout]     |        ^^^^^^^^ help: convert the identifier to snake case: `peek_char`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `newToken` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:176:8
[INFO] [stdout]     |
[INFO] [stdout] 176 | pub fn newToken(tokenType: token::TokenType, ch: &Option<String>) -> Token {
[INFO] [stdout]     |        ^^^^^^^^ help: convert the identifier to snake case: `new_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `tokenType` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:176:17
[INFO] [stdout]     |
[INFO] [stdout] 176 | pub fn newToken(tokenType: token::TokenType, ch: &Option<String>) -> Token {
[INFO] [stdout]     |                 ^^^^^^^^^ help: convert the identifier to snake case: `token_type`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `isLetter` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:183:4
[INFO] [stdout]     |
[INFO] [stdout] 183 | fn isLetter(s: &Option<String>) -> bool {
[INFO] [stdout]     |    ^^^^^^^^ help: convert the identifier to snake case: `is_letter`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `isDigit` should have a snake case name
[INFO] [stdout]    --> src/lexer.rs:193:4
[INFO] [stdout]     |
[INFO] [stdout] 193 | fn isDigit(s: &Option<String>) -> bool {
[INFO] [stdout]     |    ^^^^^^^ help: convert the identifier to snake case: `is_digit`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: static variable `precedences` should have an upper case name
[INFO] [stdout]   --> src/parser.rs:13:8
[INFO] [stdout]    |
[INFO] [stdout] 13 | static precedences: phf::Map<&'static str, i32> = phf_map! {
[INFO] [stdout]    |        ^^^^^^^^^^^ help: convert the identifier to upper case: `PRECEDENCES`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(non_upper_case_globals)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `curToken` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:27:5
[INFO] [stdout]    |
[INFO] [stdout] 27 |     curToken: token::Token,
[INFO] [stdout]    |     ^^^^^^^^ help: convert the identifier to snake case: `cur_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `peekToken` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:28:5
[INFO] [stdout]    |
[INFO] [stdout] 28 |     peekToken: token::Token,
[INFO] [stdout]    |     ^^^^^^^^^ help: convert the identifier to snake case: `peek_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `New` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:33:12
[INFO] [stdout]    |
[INFO] [stdout] 33 |     pub fn New(self) -> Parser {
[INFO] [stdout]    |            ^^^ help: convert the identifier to snake case: `new`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `nextToken` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:47:8
[INFO] [stdout]    |
[INFO] [stdout] 47 |     fn nextToken(&mut self) {
[INFO] [stdout]    |        ^^^^^^^^^ help: convert the identifier to snake case: `next_token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `ParseProgram` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:52:12
[INFO] [stdout]    |
[INFO] [stdout] 52 |     pub fn ParseProgram(&mut self) -> Program {
[INFO] [stdout]    |            ^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_program`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseStatement` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:64:8
[INFO] [stdout]    |
[INFO] [stdout] 64 |     fn parseStatement(&mut self) -> Option<ast::Statement> {
[INFO] [stdout]    |        ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseLetStatement` should have a snake case name
[INFO] [stdout]   --> src/parser.rs:72:8
[INFO] [stdout]    |
[INFO] [stdout] 72 |     fn parseLetStatement(&mut self) -> Option<ast::Statement> {
[INFO] [stdout]    |        ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_let_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `curTokenIs` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:102:8
[INFO] [stdout]     |
[INFO] [stdout] 102 |     fn curTokenIs(&self, t: token::TokenType) -> bool {
[INFO] [stdout]     |        ^^^^^^^^^^ help: convert the identifier to snake case: `cur_token_is`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `peekTokenIs` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:106:8
[INFO] [stdout]     |
[INFO] [stdout] 106 |     fn peekTokenIs(&self, t: token::TokenType) -> bool {
[INFO] [stdout]     |        ^^^^^^^^^^^ help: convert the identifier to snake case: `peek_token_is`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `expectPeek` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:110:8
[INFO] [stdout]     |
[INFO] [stdout] 110 |     fn expectPeek(&mut self, t: token::TokenType) -> bool {
[INFO] [stdout]     |        ^^^^^^^^^^ help: convert the identifier to snake case: `expect_peek`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `Errors` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:120:12
[INFO] [stdout]     |
[INFO] [stdout] 120 |     pub fn Errors(&self) -> &Vec<String> {
[INFO] [stdout]     |            ^^^^^^ help: convert the identifier to snake case: `errors`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `peekError` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:124:8
[INFO] [stdout]     |
[INFO] [stdout] 124 |     fn peekError(&mut self, t: token::TokenType) {
[INFO] [stdout]     |        ^^^^^^^^^ help: convert the identifier to snake case: `peek_error`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `checkParserErrors` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:132:12
[INFO] [stdout]     |
[INFO] [stdout] 132 |     pub fn checkParserErrors(&self) {
[INFO] [stdout]     |            ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `check_parser_errors`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseReturnStatement` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:144:8
[INFO] [stdout]     |
[INFO] [stdout] 144 |     fn parseReturnStatement(&mut self) -> Option<ast::Statement> {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_return_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseExpressionStatement` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:159:8
[INFO] [stdout]     |
[INFO] [stdout] 159 |     fn parseExpressionStatement(&mut self) -> Option<ast::Statement> {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_expression_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:177:8
[INFO] [stdout]     |
[INFO] [stdout] 177 |     fn parseExpression(&mut self, precedence: i32) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseIntergerLiteral` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:243:8
[INFO] [stdout]     |
[INFO] [stdout] 243 |     fn parseIntergerLiteral(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_interger_literal`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parsePrefixExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:259:8
[INFO] [stdout]     |
[INFO] [stdout] 259 |     fn parsePrefixExpression(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_prefix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `peekPrecedence` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:270:8
[INFO] [stdout]     |
[INFO] [stdout] 270 |     fn peekPrecedence(&self) -> i32 {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `peek_precedence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `curPrecedence` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:278:8
[INFO] [stdout]     |
[INFO] [stdout] 278 |     fn curPrecedence(&self) -> i32 {
[INFO] [stdout]     |        ^^^^^^^^^^^^^ help: convert the identifier to snake case: `cur_precedence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseInfixExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:286:8
[INFO] [stdout]     |
[INFO] [stdout] 286 |     fn parseInfixExpression(&mut self, left: ast::Expression) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_infix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseBoolean` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:299:8
[INFO] [stdout]     |
[INFO] [stdout] 299 |     fn parseBoolean(&self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_boolean`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseGroupedExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:306:8
[INFO] [stdout]     |
[INFO] [stdout] 306 |     fn parseGroupedExpression(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_grouped_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseIfExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:317:8
[INFO] [stdout]     |
[INFO] [stdout] 317 |     fn parseIfExpression(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_if_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseBlockStatement` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:354:8
[INFO] [stdout]     |
[INFO] [stdout] 354 |     fn parseBlockStatement(&mut self) -> ast::Statement {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_block_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseFunctionLiteral` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:374:8
[INFO] [stdout]     |
[INFO] [stdout] 374 |     fn parseFunctionLiteral(&mut self) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_function_literal`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseFunctionParameters` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:397:8
[INFO] [stdout]     |
[INFO] [stdout] 397 |     fn parseFunctionParameters(&mut self) -> Option<Vec<ast::Expression>> {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_function_parameters`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseCallExpression` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:430:8
[INFO] [stdout]     |
[INFO] [stdout] 430 |     fn parseCallExpression(&mut self, function: ast::Expression) -> ast::Expression {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_call_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `parseCallArguments` should have a snake case name
[INFO] [stdout]    --> src/parser.rs:441:8
[INFO] [stdout]     |
[INFO] [stdout] 441 |     fn parseCallArguments(&mut self) -> Option<Vec<ast::Expression>> {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `parse_call_arguments`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `Start` should have a snake case name
[INFO] [stdout]  --> src/repl.rs:6:8
[INFO] [stdout]   |
[INFO] [stdout] 6 | pub fn Start() {
[INFO] [stdout]   |        ^^^^^ help: convert the identifier to snake case (notice the capitalization): `start`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `printParserErrors` should have a snake case name
[INFO] [stdout]   --> src/repl.rs:27:4
[INFO] [stdout]    |
[INFO] [stdout] 27 | fn printParserErrors(errors: &Vec<String>) {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `print_parser_errors`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Type` should have a snake case name
[INFO] [stdout]   --> src/token.rs:41:9
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub Type: TokenType,
[INFO] [stdout]    |         ^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: rename the identifier or convert it to a snake case raw identifier
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub r#type: TokenType,
[INFO] [stdout]    |         ^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Literal` should have a snake case name
[INFO] [stdout]   --> src/token.rs:42:9
[INFO] [stdout]    |
[INFO] [stdout] 42 |     pub Literal: String,
[INFO] [stdout]    |         ^^^^^^^ help: convert the identifier to snake case: `literal`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `LookupIdent` should have a snake case name
[INFO] [stdout]   --> src/token.rs:60:8
[INFO] [stdout]    |
[INFO] [stdout] 60 | pub fn LookupIdent(ident: &String) -> TokenType {
[INFO] [stdout]    |        ^^^^^^^^^^^ help: convert the identifier to snake case: `lookup_ident`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/object.rs:12:13
[INFO] [stdout]    |
[INFO] [stdout] 12 |     Integer{Value: i64},
[INFO] [stdout]    |             ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/object.rs:13:13
[INFO] [stdout]    |
[INFO] [stdout] 13 |     Boolean{Value: bool},
[INFO] [stdout]    |             ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `Value` should have a snake case name
[INFO] [stdout]   --> src/object.rs:14:17
[INFO] [stdout]    |
[INFO] [stdout] 14 |     ReturnValue{Value: Box<Object>},
[INFO] [stdout]    |                 ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `Type` should have a snake case name
[INFO] [stdout]   --> src/object.rs:19:12
[INFO] [stdout]    |
[INFO] [stdout] 19 |     pub fn Type(&self) -> ObjectType {
[INFO] [stdout]    |            ^^^^
[INFO] [stdout]    |
[INFO] [stdout] help: rename the identifier or convert it to a snake case raw identifier
[INFO] [stdout]    |
[INFO] [stdout] 19 |     pub fn r#type(&self) -> ObjectType {
[INFO] [stdout]    |            ^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: method `Inspect` should have a snake case name
[INFO] [stdout]   --> src/object.rs:28:12
[INFO] [stdout]    |
[INFO] [stdout] 28 |     pub fn Inspect(&self) -> String {
[INFO] [stdout]    |            ^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `inspect`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `Eval` should have a snake case name
[INFO] [stdout]  --> src/evaluator.rs:7:8
[INFO] [stdout]   |
[INFO] [stdout] 7 | pub fn Eval(node: ast::Program) -> object::Object {
[INFO] [stdout]   |        ^^^^ help: convert the identifier to snake case: `eval`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalStatements` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:11:4
[INFO] [stdout]    |
[INFO] [stdout] 11 | fn evalStatements(stmts: &Vec<ast::Statement>) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalStatement` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:23:4
[INFO] [stdout]    |
[INFO] [stdout] 23 | fn evalStatement(stmt: &ast::Statement) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:25:45
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ast::Statement::ExpressionStatement{Token, Expression} => evalExpression(Expression),
[INFO] [stdout]    |                                             ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:25:52
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ast::Statement::ExpressionStatement{Token, Expression} => evalExpression(Expression),
[INFO] [stdout]    |                                                    ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:26:40
[INFO] [stdout]    |
[INFO] [stdout] 26 |         ast::Statement::BlockStatement{Token, Statements} => evalBlockStatement(stmt),
[INFO] [stdout]    |                                        ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:26:47
[INFO] [stdout]    |
[INFO] [stdout] 26 |         ast::Statement::BlockStatement{Token, Statements} => evalBlockStatement(stmt),
[INFO] [stdout]    |                                               ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:27:41
[INFO] [stdout]    |
[INFO] [stdout] 27 |         ast::Statement::ReturnStatement{Token, ReturnValue} => {
[INFO] [stdout]    |                                         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `ReturnValue` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:27:48
[INFO] [stdout]    |
[INFO] [stdout] 27 |         ast::Statement::ReturnStatement{Token, ReturnValue} => {
[INFO] [stdout]    |                                                ^^^^^^^^^^^ help: convert the identifier to snake case: `return_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:35:4
[INFO] [stdout]    |
[INFO] [stdout] 35 | fn evalExpression(exp: &ast::Expression) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:37:42
[INFO] [stdout]    |
[INFO] [stdout] 37 |         ast::Expression::IntergerLiteral{Token, Value} => object::Object::Integer{Value: *Value},
[INFO] [stdout]    |                                          ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:37:49
[INFO] [stdout]    |
[INFO] [stdout] 37 |         ast::Expression::IntergerLiteral{Token, Value} => object::Object::Integer{Value: *Value},
[INFO] [stdout]    |                                                 ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:38:34
[INFO] [stdout]    |
[INFO] [stdout] 38 |         ast::Expression::Boolean{Token, Value} => if *Value {TRUE} else {FALSE},
[INFO] [stdout]    |                                  ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:38:41
[INFO] [stdout]    |
[INFO] [stdout] 38 |         ast::Expression::Boolean{Token, Value} => if *Value {TRUE} else {FALSE},
[INFO] [stdout]    |                                         ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:39:43
[INFO] [stdout]    |
[INFO] [stdout] 39 |         ast::Expression::PrefixExpression{Token, Operator, Right} => {
[INFO] [stdout]    |                                           ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:39:50
[INFO] [stdout]    |
[INFO] [stdout] 39 |         ast::Expression::PrefixExpression{Token, Operator, Right} => {
[INFO] [stdout]    |                                                  ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:39:60
[INFO] [stdout]    |
[INFO] [stdout] 39 |         ast::Expression::PrefixExpression{Token, Operator, Right} => {
[INFO] [stdout]    |                                                            ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:47:42
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                          ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Left` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:47:49
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                                 ^^^^ help: convert the identifier to snake case: `left`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:47:55
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                                       ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:47:65
[INFO] [stdout]    |
[INFO] [stdout] 47 |         ast::Expression::InfixExpression{Token, Left, Operator, Right} => {
[INFO] [stdout]    |                                                                 ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:52:39
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                       ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Condition` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:52:46
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                              ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Consequence` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:52:57
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                                         ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Alternative` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:52:70
[INFO] [stdout]    |
[INFO] [stdout] 52 |         ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} => {
[INFO] [stdout]    |                                                                      ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalPrefixExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:59:4
[INFO] [stdout]    |
[INFO] [stdout] 59 | fn evalPrefixExpression(operator: &String, right: object::Object) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_prefix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalBangOperatorExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:67:4
[INFO] [stdout]    |
[INFO] [stdout] 67 | fn evalBangOperatorExpression(right: object::Object) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_bang_operator_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalMinusPrefixOperatorExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:76:4
[INFO] [stdout]    |
[INFO] [stdout] 76 | fn evalMinusPrefixOperatorExpression(right: object::Object) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_minus_prefix_operator_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalInfixExpression` should have a snake case name
[INFO] [stdout]   --> src/evaluator.rs:84:4
[INFO] [stdout]    |
[INFO] [stdout] 84 | fn evalInfixExpression(operator: &String, left: object::Object, right: object::Object) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_infix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalIntegerInfixExpression` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:101:4
[INFO] [stdout]     |
[INFO] [stdout] 101 | fn evalIntegerInfixExpression(operator: &String, left: i64, right:i64) -> object::Object {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_integer_infix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalIfExpression` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:115:4
[INFO] [stdout]     |
[INFO] [stdout] 115 | fn evalIfExpression(ie: &ast::Expression) -> object::Object {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_if_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:116:42
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                          ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Condition` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:116:49
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                                 ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Consequence` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:116:60
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Alternative` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:116:73
[INFO] [stdout]     |
[INFO] [stdout] 116 |     if let ast::Expression::IfExpression{Token, Condition, Consequence, Alternative} = ie {
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `isTruthy` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:131:4
[INFO] [stdout]     |
[INFO] [stdout] 131 | fn isTruthy(obj: &object::Object) -> bool {
[INFO] [stdout]     |    ^^^^^^^^ help: convert the identifier to snake case: `is_truthy`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `evalBlockStatement` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:140:4
[INFO] [stdout]     |
[INFO] [stdout] 140 | fn evalBlockStatement(block: &ast::Statement) -> object::Object {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `eval_block_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:141:43
[INFO] [stdout]     |
[INFO] [stdout] 141 |     if let ast::Statement::BlockStatement{Token, Statements} = block {
[INFO] [stdout]     |                                           ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]    --> src/evaluator.rs:141:50
[INFO] [stdout]     |
[INFO] [stdout] 141 |     if let ast::Statement::BlockStatement{Token, Statements} = block {
[INFO] [stdout]     |                                                  ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 189 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0170`.
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `ast`, `parser`
[INFO] [stdout]  --> tests/evaluator_test.rs:2:41
[INFO] [stdout]   |
[INFO] [stdout] 2 | use monkey_interpreter::{lexer, object, parser, evaluator, ast};
[INFO] [stdout]   |                                         ^^^^^^             ^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]  --> tests/evaluator_test.rs:6:12
[INFO] [stdout]   |
[INFO] [stdout] 6 |     struct tests_struct {
[INFO] [stdout]   |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_camel_case_types)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]   --> tests/evaluator_test.rs:59:12
[INFO] [stdout]    |
[INFO] [stdout] 59 |     struct tests_struct {
[INFO] [stdout]    |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]    --> tests/evaluator_test.rs:107:12
[INFO] [stdout]     |
[INFO] [stdout] 107 |     struct tests_struct {
[INFO] [stdout]     |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]    --> tests/evaluator_test.rs:128:12
[INFO] [stdout]     |
[INFO] [stdout] 128 |     struct tests_struct {
[INFO] [stdout]     |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]    --> tests/evaluator_test.rs:164:12
[INFO] [stdout]     |
[INFO] [stdout] 164 |     struct tests_struct {
[INFO] [stdout]     |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestNextToken` should have a snake case name
[INFO] [stdout]  --> tests/lexer_test.rs:6:4
[INFO] [stdout]   |
[INFO] [stdout] 6 | fn TestNextToken() {
[INFO] [stdout]   |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_next_token`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `expectedType` should have a snake case name
[INFO] [stdout]  --> tests/lexer_test.rs:9:9
[INFO] [stdout]   |
[INFO] [stdout] 9 |         expectedType: token::TokenType,
[INFO] [stdout]   |         ^^^^^^^^^^^^ help: convert the identifier to snake case: `expected_type`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `expectedLiteral` should have a snake case name
[INFO] [stdout]   --> tests/lexer_test.rs:10:9
[INFO] [stdout]    |
[INFO] [stdout] 10 |         expectedLiteral: String,
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `expected_literal`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 3 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestEvalIntegerExpression` should have a snake case name
[INFO] [stdout]  --> tests/evaluator_test.rs:5:4
[INFO] [stdout]   |
[INFO] [stdout] 5 | fn TestEvalIntegerExpression() {
[INFO] [stdout]   |    ^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_eval_integer_expression`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `parser`
[INFO] [stdout]  --> tests/parser_test.rs:2:38
[INFO] [stdout]   |
[INFO] [stdout] 2 | use monkey_interpreter::{ast, lexer, parser, token, token::Token};
[INFO] [stdout]   |                                      ^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testEval` should have a snake case name
[INFO] [stdout]   --> tests/evaluator_test.rs:36:4
[INFO] [stdout]    |
[INFO] [stdout] 36 | fn testEval(input: &String) -> object::Object {
[INFO] [stdout]    |    ^^^^^^^^ help: convert the identifier to snake case: `test_eval`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testIntegerObject` should have a snake case name
[INFO] [stdout]   --> tests/evaluator_test.rs:43:4
[INFO] [stdout]    |
[INFO] [stdout] 43 | fn testIntegerObject(obj: &object::Object, expected: i64) -> bool {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_integer_object`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestEvalBooleanExpression` should have a snake case name
[INFO] [stdout]   --> tests/evaluator_test.rs:58:4
[INFO] [stdout]    |
[INFO] [stdout] 58 | fn TestEvalBooleanExpression() {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_eval_boolean_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testBooleanObject` should have a snake case name
[INFO] [stdout]   --> tests/evaluator_test.rs:91:4
[INFO] [stdout]    |
[INFO] [stdout] 91 | fn testBooleanObject(obj: &object::Object, expected: bool) -> bool {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_boolean_object`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestBangOperator` should have a snake case name
[INFO] [stdout]    --> tests/evaluator_test.rs:106:4
[INFO] [stdout]     |
[INFO] [stdout] 106 | fn TestBangOperator() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_bang_operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestIfElseExpressions` should have a snake case name
[INFO] [stdout]    --> tests/evaluator_test.rs:127:4
[INFO] [stdout]     |
[INFO] [stdout] 127 | fn TestIfElseExpressions() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_if_else_expressions`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]   --> tests/parser_test.rs:10:12
[INFO] [stdout]    |
[INFO] [stdout] 10 |     struct tests_struct {
[INFO] [stdout]    |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(non_camel_case_types)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testNullObject` should have a snake case name
[INFO] [stdout]    --> tests/evaluator_test.rs:153:4
[INFO] [stdout]     |
[INFO] [stdout] 153 | fn testNullObject(obj: &object::Object) -> bool{
[INFO] [stdout]     |    ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_null_object`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]    --> tests/parser_test.rs:111:12
[INFO] [stdout]     |
[INFO] [stdout] 111 |     struct tests_struct {
[INFO] [stdout]     |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestReturnStatements` should have a snake case name
[INFO] [stdout]    --> tests/evaluator_test.rs:163:4
[INFO] [stdout]     |
[INFO] [stdout] 163 | fn TestReturnStatements() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_return_statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `prefixTests_struct` should have an upper camel case name
[INFO] [stdout]    --> tests/parser_test.rs:248:12
[INFO] [stdout]     |
[INFO] [stdout] 248 |     struct prefixTests_struct {
[INFO] [stdout]     |            ^^^^^^^^^^^^^^^^^^ help: convert the identifier to upper camel case: `PrefixTestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `infixTests_struct` should have an upper camel case name
[INFO] [stdout]    --> tests/parser_test.rs:384:12
[INFO] [stdout]     |
[INFO] [stdout] 384 |     struct infixTests_struct {
[INFO] [stdout]     |            ^^^^^^^^^^^^^^^^^ help: convert the identifier to upper camel case: `InfixTestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]    --> tests/parser_test.rs:778:12
[INFO] [stdout]     |
[INFO] [stdout] 778 |     struct tests_struct {
[INFO] [stdout]     |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]    --> tests/parser_test.rs:963:12
[INFO] [stdout]     |
[INFO] [stdout] 963 |     struct tests_struct {
[INFO] [stdout]     |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `tests_struct` should have an upper camel case name
[INFO] [stdout]     --> tests/parser_test.rs:1329:12
[INFO] [stdout]      |
[INFO] [stdout] 1329 |     struct tests_struct {
[INFO] [stdout]      |            ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `TestsStruct`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 15 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:918:44
[INFO] [stdout]     |
[INFO] [stdout] 918 |         ast::Expression::IntergerLiteral { Token, Value } => testIntegerLiteral(&exp, *Value),
[INFO] [stdout]     |                                            ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:920:36
[INFO] [stdout]     |
[INFO] [stdout] 920 |         ast::Expression::Boolean { Token, Value } => testBooleanLiteral(exp, *Value),
[INFO] [stdout]     |                                    ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:935:9
[INFO] [stdout]     |
[INFO] [stdout] 935 |         Token,
[INFO] [stdout]     |         ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]   --> tests/parser_test.rs:69:47
[INFO] [stdout]    |
[INFO] [stdout] 69 |         if let ast::Statement::LetStatement { Token, Name, Value } = stmt {
[INFO] [stdout]    |                                               ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Name`
[INFO] [stdout]   --> tests/parser_test.rs:69:54
[INFO] [stdout]    |
[INFO] [stdout] 69 |         if let ast::Statement::LetStatement { Token, Name, Value } = stmt {
[INFO] [stdout]    |                                                      ^^^^ help: try ignoring the field: `Name: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:196:50
[INFO] [stdout]     |
[INFO] [stdout] 196 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                  ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:228:50
[INFO] [stdout]     |
[INFO] [stdout] 228 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                  ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:337:54
[INFO] [stdout]     |
[INFO] [stdout] 337 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                      ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:339:17
[INFO] [stdout]     |
[INFO] [stdout] 339 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:750:54
[INFO] [stdout]     |
[INFO] [stdout] 750 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                      ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:752:17
[INFO] [stdout]     |
[INFO] [stdout] 752 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:995:54
[INFO] [stdout]     |
[INFO] [stdout] 995 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                      ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]    --> tests/parser_test.rs:996:47
[INFO] [stdout]     |
[INFO] [stdout] 996 |             if let ast::Expression::Boolean { Token, Value } = Expression {
[INFO] [stdout]     |                                               ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1043:50
[INFO] [stdout]      |
[INFO] [stdout] 1043 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                  ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1045:13
[INFO] [stdout]      |
[INFO] [stdout] 1045 |             Token,
[INFO] [stdout]      |             ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1072:53
[INFO] [stdout]      |
[INFO] [stdout] 1072 |             if let ast::Statement::BlockStatement { Token, Statements } = Consequence.as_ref() {
[INFO] [stdout]      |                                                     ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1080:62
[INFO] [stdout]      |
[INFO] [stdout] 1080 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = consequence {
[INFO] [stdout]      |                                                              ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1130:50
[INFO] [stdout]      |
[INFO] [stdout] 1130 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                  ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1132:13
[INFO] [stdout]      |
[INFO] [stdout] 1132 |             Token,
[INFO] [stdout]      |             ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1159:53
[INFO] [stdout]      |
[INFO] [stdout] 1159 |             if let ast::Statement::BlockStatement { Token, Statements } = Consequence.as_ref() {
[INFO] [stdout]      |                                                     ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1167:62
[INFO] [stdout]      |
[INFO] [stdout] 1167 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = consequence {
[INFO] [stdout]      |                                                              ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1182:53
[INFO] [stdout]      |
[INFO] [stdout] 1182 |             if let ast::Statement::BlockStatement { Token, Statements } = Alternative.as_ref() {
[INFO] [stdout]      |                                                     ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1190:62
[INFO] [stdout]      |
[INFO] [stdout] 1190 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = alternative {
[INFO] [stdout]      |                                                              ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1234:50
[INFO] [stdout]      |
[INFO] [stdout] 1234 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                  ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1236:13
[INFO] [stdout]      |
[INFO] [stdout] 1236 |             Token,
[INFO] [stdout]      |             ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1274:53
[INFO] [stdout]      |
[INFO] [stdout] 1274 |             if let ast::Statement::BlockStatement { Token, Statements } = Body.as_ref() {
[INFO] [stdout]      |                                                     ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1282:62
[INFO] [stdout]      |
[INFO] [stdout] 1282 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = bodystmt {
[INFO] [stdout]      |                                                              ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1356:54
[INFO] [stdout]      |
[INFO] [stdout] 1356 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                      ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1358:17
[INFO] [stdout]      |
[INFO] [stdout] 1358 |                 Token,
[INFO] [stdout]      |                 ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Body`
[INFO] [stdout]     --> tests/parser_test.rs:1360:17
[INFO] [stdout]      |
[INFO] [stdout] 1360 |                 Body,
[INFO] [stdout]      |                 ^^^^ help: try ignoring the field: `Body: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1416:50
[INFO] [stdout]      |
[INFO] [stdout] 1416 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                  ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `Token`
[INFO] [stdout]     --> tests/parser_test.rs:1418:13
[INFO] [stdout]      |
[INFO] [stdout] 1418 |             Token,
[INFO] [stdout]      |             ^^^^^ help: try ignoring the field: `Token: _`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> tests/parser_test.rs:184:9
[INFO] [stdout]     |
[INFO] [stdout] 184 |     let mut program = p.ParseProgram();
[INFO] [stdout]     |         ----^^^^^^^
[INFO] [stdout]     |         |
[INFO] [stdout]     |         help: remove this `mut`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_mut)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: struct is never constructed: `ExpectedIdentifiers`
[INFO] [stdout]  --> tests/parser_test.rs:4:8
[INFO] [stdout]   |
[INFO] [stdout] 4 | struct ExpectedIdentifiers {
[INFO] [stdout]   |        ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(dead_code)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `leftValue`
[INFO] [stdout]    --> tests/parser_test.rs:386:9
[INFO] [stdout]     |
[INFO] [stdout] 386 |         leftValue: ast::Expression,
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `operator`
[INFO] [stdout]    --> tests/parser_test.rs:387:9
[INFO] [stdout]     |
[INFO] [stdout] 387 |         operator: String,
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field is never read: `rightValue`
[INFO] [stdout]    --> tests/parser_test.rs:388:9
[INFO] [stdout]     |
[INFO] [stdout] 388 |         rightValue: ast::Expression,
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `expectedIdentifier` should have a snake case name
[INFO] [stdout]  --> tests/parser_test.rs:5:5
[INFO] [stdout]   |
[INFO] [stdout] 5 |     expectedIdentifier: String,
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `expected_identifier`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestLetStatements` should have a snake case name
[INFO] [stdout]  --> tests/parser_test.rs:9:4
[INFO] [stdout]   |
[INFO] [stdout] 9 | fn TestLetStatements() {
[INFO] [stdout]   |    ^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_let_statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `expectedIdentifier` should have a snake case name
[INFO] [stdout]   --> tests/parser_test.rs:12:9
[INFO] [stdout]    |
[INFO] [stdout] 12 |         expectedIdentifier: String,
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `expected_identifier`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `expectedValue` should have a snake case name
[INFO] [stdout]   --> tests/parser_test.rs:13:9
[INFO] [stdout]    |
[INFO] [stdout] 13 |         expectedValue: ast::Expression,
[INFO] [stdout]    |         ^^^^^^^^^^^^^ help: convert the identifier to snake case: `expected_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> tests/parser_test.rs:69:47
[INFO] [stdout]    |
[INFO] [stdout] 69 |         if let ast::Statement::LetStatement { Token, Name, Value } = stmt {
[INFO] [stdout]    |                                               ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Name` should have a snake case name
[INFO] [stdout]   --> tests/parser_test.rs:69:54
[INFO] [stdout]    |
[INFO] [stdout] 69 |         if let ast::Statement::LetStatement { Token, Name, Value } = stmt {
[INFO] [stdout]    |                                                      ^^^^ help: convert the identifier to snake case: `name`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]   --> tests/parser_test.rs:69:60
[INFO] [stdout]    |
[INFO] [stdout] 69 |         if let ast::Statement::LetStatement { Token, Name, Value } = stmt {
[INFO] [stdout]    |                                                            ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testLetStatement` should have a snake case name
[INFO] [stdout]   --> tests/parser_test.rs:81:4
[INFO] [stdout]    |
[INFO] [stdout] 81 | fn testLetStatement(s: &ast::Statement, name: &String) -> bool {
[INFO] [stdout]    |    ^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_let_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]   --> tests/parser_test.rs:82:43
[INFO] [stdout]    |
[INFO] [stdout] 82 |     if let ast::Statement::LetStatement { Token, Name, .. } = s {
[INFO] [stdout]    |                                           ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Name` should have a snake case name
[INFO] [stdout]   --> tests/parser_test.rs:82:50
[INFO] [stdout]    |
[INFO] [stdout] 82 |     if let ast::Statement::LetStatement { Token, Name, .. } = s {
[INFO] [stdout]    |                                                  ^^^^ help: convert the identifier to snake case: `name`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestReturnStatement` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:110:4
[INFO] [stdout]     |
[INFO] [stdout] 110 | fn TestReturnStatement() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_return_statement`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `expectedValue` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:113:9
[INFO] [stdout]     |
[INFO] [stdout] 113 |         expectedValue: ast::Expression,
[INFO] [stdout]     |         ^^^^^^^^^^^^^ help: convert the identifier to snake case: `expected_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:165:50
[INFO] [stdout]     |
[INFO] [stdout] 165 |         if let ast::Statement::ReturnStatement { Token, ReturnValue } = stmt {
[INFO] [stdout]     |                                                  ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `ReturnValue` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:165:57
[INFO] [stdout]     |
[INFO] [stdout] 165 |         if let ast::Statement::ReturnStatement { Token, ReturnValue } = stmt {
[INFO] [stdout]     |                                                         ^^^^^^^^^^^ help: convert the identifier to snake case: `return_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestIdentifierExpression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:180:4
[INFO] [stdout]     |
[INFO] [stdout] 180 | fn TestIdentifierExpression() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_identifier_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:196:50
[INFO] [stdout]     |
[INFO] [stdout] 196 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                  ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:196:57
[INFO] [stdout]     |
[INFO] [stdout] 196 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                         ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestIntegerLiteralExpression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:212:4
[INFO] [stdout]     |
[INFO] [stdout] 212 | fn TestIntegerLiteralExpression() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_integer_literal_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:228:50
[INFO] [stdout]     |
[INFO] [stdout] 228 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                  ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:228:57
[INFO] [stdout]     |
[INFO] [stdout] 228 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                         ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:229:51
[INFO] [stdout]     |
[INFO] [stdout] 229 |         if let ast::Expression::IntergerLiteral { Token, Value } = Expression {
[INFO] [stdout]     |                                                   ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:229:58
[INFO] [stdout]     |
[INFO] [stdout] 229 |         if let ast::Expression::IntergerLiteral { Token, Value } = Expression {
[INFO] [stdout]     |                                                          ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestParsingPrefixExpression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:247:4
[INFO] [stdout]     |
[INFO] [stdout] 247 | fn TestParsingPrefixExpression() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_parsing_prefix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `prefixTests` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:254:9
[INFO] [stdout]     |
[INFO] [stdout] 254 |     let prefixTests = vec![
[INFO] [stdout]     |         ^^^^^^^^^^^ help: convert the identifier to snake case: `prefix_tests`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:337:54
[INFO] [stdout]     |
[INFO] [stdout] 337 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                      ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:337:61
[INFO] [stdout]     |
[INFO] [stdout] 337 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                             ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:339:17
[INFO] [stdout]     |
[INFO] [stdout] 339 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:340:17
[INFO] [stdout]     |
[INFO] [stdout] 340 |                 Operator,
[INFO] [stdout]     |                 ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:341:17
[INFO] [stdout]     |
[INFO] [stdout] 341 |                 Right,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testIntegerLiteral` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:365:4
[INFO] [stdout]     |
[INFO] [stdout] 365 | fn testIntegerLiteral(il: &ast::Expression, value: i64) -> bool {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_integer_literal`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:366:47
[INFO] [stdout]     |
[INFO] [stdout] 366 |     if let ast::Expression::IntergerLiteral { Token, Value } = il {
[INFO] [stdout]     |                                               ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:366:54
[INFO] [stdout]     |
[INFO] [stdout] 366 |     if let ast::Expression::IntergerLiteral { Token, Value } = il {
[INFO] [stdout]     |                                                      ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestParsingInfixExpressions` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:383:4
[INFO] [stdout]     |
[INFO] [stdout] 383 | fn TestParsingInfixExpressions() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_parsing_infix_expressions`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `leftValue` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:386:9
[INFO] [stdout]     |
[INFO] [stdout] 386 |         leftValue: ast::Expression,
[INFO] [stdout]     |         ^^^^^^^^^ help: convert the identifier to snake case: `left_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `rightValue` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:388:9
[INFO] [stdout]     |
[INFO] [stdout] 388 |         rightValue: ast::Expression,
[INFO] [stdout]     |         ^^^^^^^^^^ help: convert the identifier to snake case: `right_value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `infixTests` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:390:9
[INFO] [stdout]     |
[INFO] [stdout] 390 |     let infixTests = vec![
[INFO] [stdout]     |         ^^^^^^^^^^ help: convert the identifier to snake case: `infix_tests`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:750:54
[INFO] [stdout]     |
[INFO] [stdout] 750 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                      ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:750:61
[INFO] [stdout]     |
[INFO] [stdout] 750 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                             ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:752:17
[INFO] [stdout]     |
[INFO] [stdout] 752 |                 Token,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Left` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:753:17
[INFO] [stdout]     |
[INFO] [stdout] 753 |                 Left,
[INFO] [stdout]     |                 ^^^^ help: convert the identifier to snake case: `left`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:754:17
[INFO] [stdout]     |
[INFO] [stdout] 754 |                 Operator,
[INFO] [stdout]     |                 ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:755:17
[INFO] [stdout]     |
[INFO] [stdout] 755 |                 Right,
[INFO] [stdout]     |                 ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestOperatorPrecedenceParsing` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:777:4
[INFO] [stdout]     |
[INFO] [stdout] 777 | fn TestOperatorPrecedenceParsing() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_operator_precedence_parsing`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testIdentifier` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:897:4
[INFO] [stdout]     |
[INFO] [stdout] 897 | fn testIdentifier(exp: &ast::Expression, value: String) -> bool {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_identifier`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testLiteralExpression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:916:4
[INFO] [stdout]     |
[INFO] [stdout] 916 | fn testLiteralExpression(exp: &ast::Expression, expected: &ast::Expression) -> bool {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_literal_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:918:44
[INFO] [stdout]     |
[INFO] [stdout] 918 |         ast::Expression::IntergerLiteral { Token, Value } => testIntegerLiteral(&exp, *Value),
[INFO] [stdout]     |                                            ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:918:51
[INFO] [stdout]     |
[INFO] [stdout] 918 |         ast::Expression::IntergerLiteral { Token, Value } => testIntegerLiteral(&exp, *Value),
[INFO] [stdout]     |                                                   ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:920:36
[INFO] [stdout]     |
[INFO] [stdout] 920 |         ast::Expression::Boolean { Token, Value } => testBooleanLiteral(exp, *Value),
[INFO] [stdout]     |                                    ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:920:43
[INFO] [stdout]     |
[INFO] [stdout] 920 |         ast::Expression::Boolean { Token, Value } => testBooleanLiteral(exp, *Value),
[INFO] [stdout]     |                                           ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testInfixExpression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:928:4
[INFO] [stdout]     |
[INFO] [stdout] 928 | fn testInfixExpression(
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_infix_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:935:9
[INFO] [stdout]     |
[INFO] [stdout] 935 |         Token,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Left` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:936:9
[INFO] [stdout]     |
[INFO] [stdout] 936 |         Left,
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case: `left`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Operator` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:937:9
[INFO] [stdout]     |
[INFO] [stdout] 937 |         Operator,
[INFO] [stdout]     |         ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `operator`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Right` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:938:9
[INFO] [stdout]     |
[INFO] [stdout] 938 |         Right,
[INFO] [stdout]     |         ^^^^^ help: convert the identifier to snake case: `right`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestBooleanExpression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:962:4
[INFO] [stdout]     |
[INFO] [stdout] 962 | fn TestBooleanExpression() {
[INFO] [stdout]     |    ^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_boolean_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `expectedBoolean` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:965:9
[INFO] [stdout]     |
[INFO] [stdout] 965 |         expectedBoolean: bool,
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `expected_boolean`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:995:54
[INFO] [stdout]     |
[INFO] [stdout] 995 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                      ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:995:61
[INFO] [stdout]     |
[INFO] [stdout] 995 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]     |                                                             ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:996:47
[INFO] [stdout]     |
[INFO] [stdout] 996 |             if let ast::Expression::Boolean { Token, Value } = Expression {
[INFO] [stdout]     |                                               ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]    --> tests/parser_test.rs:996:54
[INFO] [stdout]     |
[INFO] [stdout] 996 |             if let ast::Expression::Boolean { Token, Value } = Expression {
[INFO] [stdout]     |                                                      ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `testBooleanLiteral` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1007:4
[INFO] [stdout]      |
[INFO] [stdout] 1007 | fn testBooleanLiteral(exp: &ast::Expression, value: bool) -> bool {
[INFO] [stdout]      |    ^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_boolean_literal`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1008:39
[INFO] [stdout]      |
[INFO] [stdout] 1008 |     if let ast::Expression::Boolean { Token, Value } = exp {
[INFO] [stdout]      |                                       ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Value` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1008:46
[INFO] [stdout]      |
[INFO] [stdout] 1008 |     if let ast::Expression::Boolean { Token, Value } = exp {
[INFO] [stdout]      |                                              ^^^^^ help: convert the identifier to snake case (notice the capitalization): `value`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestIfExpression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1026:4
[INFO] [stdout]      |
[INFO] [stdout] 1026 | fn TestIfExpression() {
[INFO] [stdout]      |    ^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_if_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1043:50
[INFO] [stdout]      |
[INFO] [stdout] 1043 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                  ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1043:57
[INFO] [stdout]      |
[INFO] [stdout] 1043 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                         ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1045:13
[INFO] [stdout]      |
[INFO] [stdout] 1045 |             Token,
[INFO] [stdout]      |             ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Condition` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1046:13
[INFO] [stdout]      |
[INFO] [stdout] 1046 |             Condition,
[INFO] [stdout]      |             ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Consequence` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1047:13
[INFO] [stdout]      |
[INFO] [stdout] 1047 |             Consequence,
[INFO] [stdout]      |             ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Alternative` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1048:13
[INFO] [stdout]      |
[INFO] [stdout] 1048 |             Alternative,
[INFO] [stdout]      |             ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1072:53
[INFO] [stdout]      |
[INFO] [stdout] 1072 |             if let ast::Statement::BlockStatement { Token, Statements } = Consequence.as_ref() {
[INFO] [stdout]      |                                                     ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1072:60
[INFO] [stdout]      |
[INFO] [stdout] 1072 |             if let ast::Statement::BlockStatement { Token, Statements } = Consequence.as_ref() {
[INFO] [stdout]      |                                                            ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1080:62
[INFO] [stdout]      |
[INFO] [stdout] 1080 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = consequence {
[INFO] [stdout]      |                                                              ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1080:69
[INFO] [stdout]      |
[INFO] [stdout] 1080 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = consequence {
[INFO] [stdout]      |                                                                     ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestIfElseExpression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1113:4
[INFO] [stdout]      |
[INFO] [stdout] 1113 | fn TestIfElseExpression() {
[INFO] [stdout]      |    ^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_if_else_expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1130:50
[INFO] [stdout]      |
[INFO] [stdout] 1130 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                  ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1130:57
[INFO] [stdout]      |
[INFO] [stdout] 1130 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                         ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1132:13
[INFO] [stdout]      |
[INFO] [stdout] 1132 |             Token,
[INFO] [stdout]      |             ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Condition` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1133:13
[INFO] [stdout]      |
[INFO] [stdout] 1133 |             Condition,
[INFO] [stdout]      |             ^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `condition`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Consequence` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1134:13
[INFO] [stdout]      |
[INFO] [stdout] 1134 |             Consequence,
[INFO] [stdout]      |             ^^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `consequence`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Alternative` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1135:13
[INFO] [stdout]      |
[INFO] [stdout] 1135 |             Alternative,
[INFO] [stdout]      |             ^^^^^^^^^^^ help: convert the identifier to snake case: `alternative`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1159:53
[INFO] [stdout]      |
[INFO] [stdout] 1159 |             if let ast::Statement::BlockStatement { Token, Statements } = Consequence.as_ref() {
[INFO] [stdout]      |                                                     ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1159:60
[INFO] [stdout]      |
[INFO] [stdout] 1159 |             if let ast::Statement::BlockStatement { Token, Statements } = Consequence.as_ref() {
[INFO] [stdout]      |                                                            ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1167:62
[INFO] [stdout]      |
[INFO] [stdout] 1167 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = consequence {
[INFO] [stdout]      |                                                              ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1167:69
[INFO] [stdout]      |
[INFO] [stdout] 1167 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = consequence {
[INFO] [stdout]      |                                                                     ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1182:53
[INFO] [stdout]      |
[INFO] [stdout] 1182 |             if let ast::Statement::BlockStatement { Token, Statements } = Alternative.as_ref() {
[INFO] [stdout]      |                                                     ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1182:60
[INFO] [stdout]      |
[INFO] [stdout] 1182 |             if let ast::Statement::BlockStatement { Token, Statements } = Alternative.as_ref() {
[INFO] [stdout]      |                                                            ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1190:62
[INFO] [stdout]      |
[INFO] [stdout] 1190 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = alternative {
[INFO] [stdout]      |                                                              ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1190:69
[INFO] [stdout]      |
[INFO] [stdout] 1190 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = alternative {
[INFO] [stdout]      |                                                                     ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestFunctionLiteralParsing` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1219:4
[INFO] [stdout]      |
[INFO] [stdout] 1219 | fn TestFunctionLiteralParsing() {
[INFO] [stdout]      |    ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_function_literal_parsing`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1234:50
[INFO] [stdout]      |
[INFO] [stdout] 1234 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                  ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1234:57
[INFO] [stdout]      |
[INFO] [stdout] 1234 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                         ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1236:13
[INFO] [stdout]      |
[INFO] [stdout] 1236 |             Token,
[INFO] [stdout]      |             ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Parameters` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1237:13
[INFO] [stdout]      |
[INFO] [stdout] 1237 |             Parameters,
[INFO] [stdout]      |             ^^^^^^^^^^ help: convert the identifier to snake case: `parameters`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Body` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1238:13
[INFO] [stdout]      |
[INFO] [stdout] 1238 |             Body,
[INFO] [stdout]      |             ^^^^ help: convert the identifier to snake case: `body`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1274:53
[INFO] [stdout]      |
[INFO] [stdout] 1274 |             if let ast::Statement::BlockStatement { Token, Statements } = Body.as_ref() {
[INFO] [stdout]      |                                                     ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Statements` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1274:60
[INFO] [stdout]      |
[INFO] [stdout] 1274 |             if let ast::Statement::BlockStatement { Token, Statements } = Body.as_ref() {
[INFO] [stdout]      |                                                            ^^^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `statements`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1282:62
[INFO] [stdout]      |
[INFO] [stdout] 1282 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = bodystmt {
[INFO] [stdout]      |                                                              ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1282:69
[INFO] [stdout]      |
[INFO] [stdout] 1282 |                 if let ast::Statement::ExpressionStatement { Token, Expression } = bodystmt {
[INFO] [stdout]      |                                                                     ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestFunctionParameterParsing` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1328:4
[INFO] [stdout]      |
[INFO] [stdout] 1328 | fn TestFunctionParameterParsing() {
[INFO] [stdout]      |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_function_parameter_parsing`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `expectedParams` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1331:9
[INFO] [stdout]      |
[INFO] [stdout] 1331 |         expectedParams: Vec<String>,
[INFO] [stdout]      |         ^^^^^^^^^^^^^^ help: convert the identifier to snake case: `expected_params`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1356:54
[INFO] [stdout]      |
[INFO] [stdout] 1356 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                      ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1356:61
[INFO] [stdout]      |
[INFO] [stdout] 1356 |         if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                             ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1358:17
[INFO] [stdout]      |
[INFO] [stdout] 1358 |                 Token,
[INFO] [stdout]      |                 ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Parameters` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1359:17
[INFO] [stdout]      |
[INFO] [stdout] 1359 |                 Parameters,
[INFO] [stdout]      |                 ^^^^^^^^^^ help: convert the identifier to snake case: `parameters`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Body` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1360:17
[INFO] [stdout]      |
[INFO] [stdout] 1360 |                 Body,
[INFO] [stdout]      |                 ^^^^ help: convert the identifier to snake case: `body`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `TestCallExpressionParsing` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1401:4
[INFO] [stdout]      |
[INFO] [stdout] 1401 | fn TestCallExpressionParsing() {
[INFO] [stdout]      |    ^^^^^^^^^^^^^^^^^^^^^^^^^ help: convert the identifier to snake case: `test_call_expression_parsing`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1416:50
[INFO] [stdout]      |
[INFO] [stdout] 1416 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                  ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Expression` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1416:57
[INFO] [stdout]      |
[INFO] [stdout] 1416 |     if let ast::Statement::ExpressionStatement { Token, Expression } = stmt {
[INFO] [stdout]      |                                                         ^^^^^^^^^^ help: convert the identifier to snake case: `expression`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Token` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1418:13
[INFO] [stdout]      |
[INFO] [stdout] 1418 |             Token,
[INFO] [stdout]      |             ^^^^^ help: convert the identifier to snake case: `token`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Function` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1419:13
[INFO] [stdout]      |
[INFO] [stdout] 1419 |             Function,
[INFO] [stdout]      |             ^^^^^^^^ help: convert the identifier to snake case (notice the capitalization): `function`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `Arguments` should have a snake case name
[INFO] [stdout]     --> tests/parser_test.rs:1420:13
[INFO] [stdout]      |
[INFO] [stdout] 1420 |             Arguments,
[INFO] [stdout]      |             ^^^^^^^^^ help: convert the identifier to snake case: `arguments`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 157 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 19.81s
[INFO] running `Command { std: "docker" "inspect" "93ac4fd42039aa7b6e33d7a0630457ca24b0a913febdb020e1449efca82475cf", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "93ac4fd42039aa7b6e33d7a0630457ca24b0a913febdb020e1449efca82475cf", kill_on_drop: false }`
[INFO] [stdout] 93ac4fd42039aa7b6e33d7a0630457ca24b0a913febdb020e1449efca82475cf