hardliner66/lox - Change D6K7ISJOE6TBDJLC7RKMPIAQHDBAKJVUMP4IPMDNEMQ3GD4GX7WQC

add evaluate function for expressions

Created by hardliner66 on March 4, 2024

D6K7ISJOE6TBDJLC7RKMPIAQHDBAKJVUMP4IPMDNEMQ3GD4GX7WQC

Dependencies

[2] EX6RT4XJW7QK5NAQLAPBXKC2UTOBKC7QFOGNPRVQXXDNKYTMNEQAC

In channels

main

Change contents

Replacement in test.lox at line 2 [2.1]

B:BD[2.10] → [2.10:39]

3 + 5.45 - 0.25 * -18 / (!!5)

[2.10]

// (3 + 5.45) - 0.25 * -18 / 5
2 * (3 / -true)

Insertion in src/parser.rs at line 3 [2.91]
[2.145]
[2.145]
```
    location::LocationContainer,
```
Insertion in src/parser.rs at line 8 [2.91]
[2.189]
[2.189]
```
use thiserror::Error;
```
Replacement in src/parser.rs at line 53 [2.91]
B:BD[2.1576] → [2.1576:1600]
```
        value: Literal,
```
[2.1576]
[2.1600]
```
        value: LocationContainer<Literal>,
```

Insertion in src/parser.rs at line 88 [2.91]

[2.2499]

}
#[derive(Error, Debug)]
pub enum ParseError {
    #[error("Expect ')' after expression.")]
    RightParenExpected,
    #[error("Expect expression.")]
    ExpressionExpected,
    #[error("internal compiler error: Literal has no value.")]
    EmptyLiteral,

Insertion in src/parser.rs at line 99 [2.91]
[2.2501]
[2.2501]

Replacement in src/parser.rs at line 152 [2.91]

B:BD[2.3669] → [2.3669:3714]

    fn expression(&mut self) -> Expression {

[2.3669]

[2.3714]

    fn expression(&mut self) -> Result<Expression, ParseError> {

Replacement in src/parser.rs at line 156 [2.91]

B:BD[2.3745] → [2.3745:3836]

    fn equality(&mut self) -> Expression {
        let mut expression = self.comparison();

[2.3745]

[2.3836]

    fn equality(&mut self) -> Result<Expression, ParseError> {
        let mut expression = self.comparison()?;

Replacement in src/parser.rs at line 161 [2.91]

B:BD[2.3963] → [2.3963:4006]

            let right = self.comparison();

[2.3963]

[2.4006]

            let right = self.comparison()?;

Replacement in src/parser.rs at line 169 [2.91]
B:BD[2.4186] → [2.4186:4205]
```
        expression
```
[2.4186]
[2.4205]
```
        Ok(expression)
```

Replacement in src/parser.rs at line 172 [2.91]

B:BD[2.4212] → [2.4212:4299]

    fn comparison(&mut self) -> Expression {
        let mut expression = self.term();

[2.4212]

[2.4299]

    fn comparison(&mut self) -> Result<Expression, ParseError> {
        let mut expression = self.term()?;

Replacement in src/parser.rs at line 182 [2.91]

B:BD[2.4524] → [2.4524:4561]

            let right = self.term();

[2.4524]

[2.4561]

            let right = self.term()?;

Replacement in src/parser.rs at line 190 [2.91]
B:BD[2.4741] → [2.4741:4760]
```
        expression
```
[2.4741]
[2.4760]
```
        Ok(expression)
```

Replacement in src/parser.rs at line 193 [2.91]

B:BD[2.4767] → [2.4767:4850]

    fn term(&mut self) -> Expression {
        let mut expression = self.factor();

[2.4767]

[2.4850]

    fn term(&mut self) -> Result<Expression, ParseError> {
        let mut expression = self.factor()?;

Replacement in src/parser.rs at line 196 [2.91]

B:BD[2.4851] → [2.4851:4923]

        while self.match_tokens(&[TokenType::Minus, TokenType::Plus]) {

[2.4851]

[2.4923]

        while self.match_tokens(&[TokenType::Minus, TokenType::Plus, TokenType::Tilde]) {

Replacement in src/parser.rs at line 198 [2.91]

B:BD[2.4967] → [2.4967:5006]

            let right = self.factor();

[2.4967]

[2.5006]

            let right = self.factor()?;

Replacement in src/parser.rs at line 206 [2.91]
B:BD[2.5186] → [2.5186:5205]
```
        expression
```
[2.5186]
[2.5205]
```
        Ok(expression)
```

Replacement in src/parser.rs at line 209 [2.91]

B:BD[2.5212] → [2.5212:5296]

    fn factor(&mut self) -> Expression {
        let mut expression = self.unary();

[2.5212]

[2.5296]

    fn factor(&mut self) -> Result<Expression, ParseError> {
        let mut expression = self.unary()?;

Replacement in src/parser.rs at line 214 [2.91]

B:BD[2.5413] → [2.5413:5451]

            let right = self.unary();

[2.5413]

[2.5451]

            let right = self.unary()?;

Replacement in src/parser.rs at line 222 [2.91]
B:BD[2.5631] → [2.5631:5650]
```
        expression
```
[2.5631]
[2.5650]
```
        Ok(expression)
```

Replacement in src/parser.rs at line 225 [2.91]

B:BD[2.5657] → [2.5657:5697]

    fn unary(&mut self) -> Expression {

[2.5657]

[2.5697]

    fn unary(&mut self) -> Result<Expression, ParseError> {

Replacement in src/parser.rs at line 228 [2.91]

B:BD[2.5810] → [2.5810:5880]

            let right = self.unary();
            Expression::Unary {

[2.5810]

[2.5880]

            let right = self.unary()?;
            Ok(Expression::Unary {

Replacement in src/parser.rs at line 232 [2.91]
B:BD[2.5945] → [2.5945:5959]
```
            }
```
[2.5945]
[2.5959]
```
            })
```

Replacement in src/parser.rs at line 240 [2.91]

B:BD[2.6124] → [2.6124:6179]

            self.lox.error(self.peek().line, message);

[2.6124]

[2.6179]

            self.lox.error(self.peek().location.line, message);

Replacement in src/parser.rs at line 268 [2.91]

B:BD[2.6836] → [2.6836:7761]

    fn primary(&mut self) -> Expression {
        if self.match_tokens(&[TokenType::False]) {
            Expression::Literal {
                value: Literal::Boolean(false),
            }
        } else if self.match_tokens(&[TokenType::True]) {
            Expression::Literal {
                value: Literal::Boolean(true),
            }
        } else if self.match_tokens(&[TokenType::Nil]) {
            Expression::Literal {
                value: Literal::Nil,
            }
        } else if self.match_tokens(&[TokenType::Number]) {
            let number = self.previous().literal.unwrap().as_number();
            Expression::Literal {
                value: Literal::Number(number),
            }
        } else if self.match_tokens(&[TokenType::String]) {
            let string = self.previous().lexeme.clone();
            Expression::Literal {
                value: Literal::String(string),
            }

[2.6836]

[2.7761]

    fn primary(&mut self) -> Result<Expression, ParseError> {
        if self.match_tokens(&[TokenType::Literal]) {
            let previous = self.previous();
            let inner = previous.literal.ok_or(ParseError::EmptyLiteral)?;
            Ok(Expression::Literal {
                value: LocationContainer {
                    location: previous.location.clone(),
                    inner,
                },
            })

Replacement in src/parser.rs at line 279 [2.91]

B:BD[2.7824] → [2.7824:7872]

            let expression = self.expression();

[2.7824]

[2.7872]

            let expression = self.expression()?;

Replacement in src/parser.rs at line 281 [2.91]

B:BD[2.7933] → [2.7933:7972]

                Expression::Grouping {

[2.7933]

[2.7972]

                Ok(Expression::Grouping {

Replacement in src/parser.rs at line 283 [2.91]
B:BD[2.8025] → [2.8025:8043]
```
                }
```
[2.8025]
[2.8043]
```
                })
```

Replacement in src/parser.rs at line 285 [2.91]

B:BD[2.8064] → [2.8064:8120]

                panic!("Expect ')' after expression.");

[2.8064]

[2.8120]

                Err(ParseError::RightParenExpected)

Replacement in src/parser.rs at line 288 [2.91]

B:BD[2.8151] → [2.8151:8193]

            panic!("Expect expression.");

[2.8151]

[2.8193]

            Err(ParseError::ExpressionExpected)

Replacement in src/parser.rs at line 292 [2.91]

B:BD[2.8210] → [2.8210:8320]

    pub fn parse(&mut self) -> Result<Expression, &'static str> {
        let expression = self.expression();

[2.8210]

[2.8320]

    pub fn parse(&mut self) -> Result<Expression, ParseError> {
        let expression = self.expression()?;

Insertion in src/main.rs at line 7 [2.8531]
[2.8594]
[2.8594]
```
mod location;
```

Replacement in src/main.rs at line 10 [2.8531]

B:BD[2.8611] → [2.8611:8690]

use display_tree::{CharSet, Style, StyleBuilder};
use lox::{Lox, OutputStyle};

[2.8611]

[2.8690]

// use display_tree::{CharSet, Style, StyleBuilder};
// use lox::{Lox, OutputStyle};
use lox::Lox;

Replacement in src/main.rs at line 17 [2.8531]

B:BD[2.8794] → [2.8794:8943]

    lox.options.output_style = OutputStyle::Tree(
        Style::default()
            .indentation(1)
            .char_set(CharSet::ASCII),
    );

[2.8794]

[2.8943]

    // lox.options.output_style = OutputStyle::Tree(
    //     Style::default()
    //         .indentation(1)
    //         .char_set(CharSet::ASCII),
    // );

Replacement in src/lib.rs at line 3 [2.9097]

B:BD[2.9120] → [2.9120:9166]

use std::{fmt::Debug, io::Write, path::Path};

[2.9120]

[2.9166]

use std::{borrow::Borrow, fmt::Debug, io::Write, path::Path};

Insertion in src/lib.rs at line 6 [2.9097]

[2.9207]

use location::{Location, LocationContainer};
use thiserror::Error;

Insertion in src/lib.rs at line 10 [2.9097]
[2.9219]
[2.9219]
```
mod location;
```

Replacement in src/lib.rs at line 13 [2.9097]

B:BD[2.9232] → [2.9232:9279]

use lexer::{Lexer, Token};
use parser::Parser;

[2.9232]

[2.9279]

use lexer::{Lexer, Literal, Token, TokenType, BINARY_OPERATORS, UNARY_OPERATORS};
use parser::{Expression, Parser};

Replacement in src/lib.rs at line 18 [2.9097]
B:BD[2.9320] → [2.9320:9336]
```
    Parentized,
```
[2.9320]
[2.9336]
```
    Sexp,
    Evaluate,
```

Insertion in src/lib.rs at line 24 [2.9097]

[2.9398]

}
#[derive(Error, Debug)]
pub enum EvaluationError {
    #[error("[{location}] Invalid binary operator types: {left} {operator:?} {right}")]
    InvalidBinaryOperatorType {
        location: Location,
        left: Literal,
        operator: TokenType,
        right: Literal,
    },
    #[error("[{location}] Invalid binary operator: {operator:?}")]
    InvalidBinaryOperator {
        location: Location,
        operator: TokenType,
    },
    #[error("[{location}] Invalid unary operator type: {operator:?} {right}")]
    InvalidUnaryOperatorType {
        location: Location,
        operator: TokenType,
        right: Literal,
    },
    #[error("[{location}] Invalid unary operator: {operator:?}")]
    InvalidUnaryOperator {
        location: Location,
        operator: TokenType,
    },

Replacement in src/lib.rs at line 72 [2.9097]

B:BD[2.9752] → [2.9752:9807]

                output_style: OutputStyle::Parentized,

[2.9752]

[2.9807]

                output_style: OutputStyle::Evaluate,

Replacement in src/lib.rs at line 79 [2.9097]

B:BD[2.9959] → [2.9959:10016]

            self.report(token.line, " at end", message);

[2.9959]

[2.10016]

            self.report(token.location.line, " at end", message);

Replacement in src/lib.rs at line 81 [2.9097]

B:BD[2.10033] → [2.10033:10115]

            self.report(token.line, &format!(" at '{}'", token.lexeme), message);

[2.10033]

[2.10115]

            self.report(
                token.location.line,
                &format!(" at '{}'", token.lexeme),
                message,
            );

Insertion in src/lib.rs at line 96 [2.9097]

[2.10403]

    }
    fn evaluate(&self, expr: &Expression) -> Result<LocationContainer<Literal>, EvaluationError> {
        match expr {
            Expression::Binary {
                left,
                operator,
                right,
            } => {
                let left_loc = self.evaluate(left.borrow())?;
                let right_loc = self.evaluate(right.borrow())?;
                let operator_tok = operator;
                match (
                    left_loc.inner,
                    operator_tok.get_token_type(),
                    right_loc.inner,
                ) {
                    (Literal::Number(left), TokenType::Plus, Literal::Number(right)) => {
                        Ok(LocationContainer {
                            inner: Literal::Number(left + right),
                            location: left_loc.location.clone(),
                        })
                    }
                    (Literal::Number(left), TokenType::Minus, Literal::Number(right)) => {
                        Ok(LocationContainer {
                            inner: Literal::Number(left - right),
                            location: left_loc.location.clone(),
                        })
                    }
                    (Literal::Number(left), TokenType::Star, Literal::Number(right)) => {
                        Ok(LocationContainer {
                            inner: Literal::Number(left * right),
                            location: left_loc.location.clone(),
                        })
                    }
                    (Literal::Number(left), TokenType::Slash, Literal::Number(right)) => {
                        Ok(LocationContainer {
                            inner: Literal::Number(left / right),
                            location: left_loc.location.clone(),
                        })
                    }
                    (left, TokenType::Greater, right) => Ok(LocationContainer {
                        inner: Literal::Boolean(left > right),
                        location: left_loc.location.clone(),
                    }),
                    (left, TokenType::GreaterEqual, right) => Ok(LocationContainer {
                        inner: Literal::Boolean(left >= right),
                        location: left_loc.location.clone(),
                    }),
                    (left, TokenType::Less, right) => Ok(LocationContainer {
                        inner: Literal::Boolean(left < right),
                        location: left_loc.location.clone(),
                    }),
                    (left, TokenType::LessEqual, right) => Ok(LocationContainer {
                        inner: Literal::Boolean(left <= right),
                        location: left_loc.location.clone(),
                    }),
                    (left, TokenType::EqualEqual, right) => Ok(LocationContainer {
                        inner: Literal::Boolean(left == right),
                        location: left_loc.location.clone(),
                    }),
                    (left, TokenType::BangEqual, right) => Ok(LocationContainer {
                        inner: Literal::Boolean(left != right),
                        location: left_loc.location.clone(),
                    }),
                    (Literal::String(left), TokenType::Tilde, Literal::String(right)) => {
                        Ok(LocationContainer {
                            inner: Literal::String(format!("{}{}", left, right)),
                            location: left_loc.location.clone(),
                        })
                    }
                    (left, operator, right) if BINARY_OPERATORS.contains(&operator) => {
                        Err(EvaluationError::InvalidBinaryOperatorType {
                            location: right_loc.location.clone(),
                            left,
                            operator,
                            right,
                        })
                    }
                    (_, operator, _) => Err(EvaluationError::InvalidBinaryOperator {
                        location: operator_tok.location.clone(),
                        operator,
                    }),
                }
            }
            Expression::Grouping { expression } => self.evaluate(expression),
            Expression::Literal { value } => Ok(value.clone()),
            Expression::Unary { operator, right } => {
                let right_loc = self.evaluate(right.borrow())?;
                let operator_tok = operator;
                match (operator_tok.get_token_type(), right_loc.inner) {
                    (lexer::TokenType::Minus, Literal::Number(n)) => Ok(LocationContainer {
                        inner: Literal::Number(-n),
                        location: right_loc.location.clone(),
                    }),
                    (lexer::TokenType::Bang, Literal::Boolean(b)) => Ok(LocationContainer {
                        inner: Literal::Boolean(!b),
                        location: right_loc.location.clone(),
                    }),
                    (operator, right) if UNARY_OPERATORS.contains(&operator) => {
                        Err(EvaluationError::InvalidUnaryOperatorType {
                            location: right_loc.location.clone(),
                            operator,
                            right,
                        })
                    }
                    (operator, _) => Err(EvaluationError::InvalidUnaryOperator {
                        location: operator_tok.location.clone(),
                        operator,
                    }),
                }
            }
        }

Replacement in src/lib.rs at line 218 [2.9097]

B:BD[2.10776] → [2.10776:10843]

            OutputStyle::Parentized => println!("{}", expression),

[2.10776]

[2.10843]

            OutputStyle::Sexp => println!("{}", expression),
            OutputStyle::Evaluate => {
                let result = self.evaluate(&expression);
                match result {
                    Ok(result) => println!("{}", result),
                    Err(e) => eprintln!("{}", e),
                }
            }

Replacement in src/lexer.rs at line 3 [2.11641]
B:BD[2.11679] → [2.11679:11695]
```
use crate::Lox;
```
[2.11679]
[2.11695]
```
use crate::{location::Location, Lox};
```
Insertion in src/lexer.rs at line 19 [2.11641]
[2.11923]
[2.11923]
```
    Tilde,
```
Replacement in src/lexer.rs at line 33 [2.11641]
B:BD[2.12102] → [2.12102:12126]
```
    String,
    Number,
```
[2.12102]
[2.12126]
```
    Literal,
```
Deletion in src/lexer.rs at line 39 [2.11641]
B:BD[2.12174] → [2.12174:12185]
```
    False,
```
Deletion in src/lexer.rs at line 42 [2.11641]
B:BD[2.12211] → [2.12211:12220]
```
    Nil,
```
Deletion in src/lexer.rs at line 47 [2.11641]
B:BD[2.12272] → [2.12272:12282]
```
    True,
```

Replacement in src/lexer.rs at line 53 [2.11641]

B:BD[2.12315] → [2.12315:12339]

#[derive(Clone, Debug)]

[2.12315]

[2.12339]

pub const BINARY_OPERATORS: [TokenType; 12] = [
    TokenType::Plus,
    TokenType::Minus,
    TokenType::Star,
    TokenType::Slash,
    TokenType::And,
    TokenType::Or,
    TokenType::Greater,
    TokenType::GreaterEqual,
    TokenType::Less,
    TokenType::LessEqual,
    TokenType::EqualEqual,
    TokenType::BangEqual,
];
pub const UNARY_OPERATORS: [TokenType; 2] = [TokenType::Minus, TokenType::Bang];
#[derive(Clone, Debug, PartialEq, PartialOrd)]

Replacement in src/lexer.rs at line 81 [2.11641]

B:BD[2.12537] → [2.12537:12591]

            Literal::String(s) => write!(f, "{}", s),

[2.12537]

[2.12591]

            Literal::String(s) => write!(f, "\"{}\"", s),

Replacement in src/lexer.rs at line 116 [2.11641]
B:BD[2.13356] → [2.13356:13377]
```
    pub line: usize,
```
[2.13356]
[2.13377]
```
    pub location: Location,
```

Replacement in src/lexer.rs at line 131 [2.11641]

B:BD[2.13736] → [2.13736:13811]

    pub fn new(token_type: TokenType, lexeme: &str, line: usize) -> Self {

[2.13736]

[2.13811]

    pub fn new(token_type: TokenType, lexeme: &str, line: usize, column: usize) -> Self {

Replacement in src/lexer.rs at line 135 [2.11641]
B:BD[2.13890] → [2.13890:13908]
```
            line,
```
[2.13890]
[2.13908]
```
            location: Location { line, column },
```

Insertion in src/lexer.rs at line 140 [2.11641]

[2.13952]

    pub fn get_token_type(&self) -> TokenType {
        self.token_type.clone()
    }

Insertion in src/lexer.rs at line 148 [2.11641]
[2.14055]
[2.14055]
```
        column: usize,
```
Replacement in src/lexer.rs at line 154 [2.11641]
B:BD[2.14176] → [2.14176:14194]
```
            line,
```
[2.14176]
[2.14194]
```
            location: Location { line, column },
```
Insertion in src/lexer.rs at line 167 [2.11641]
[2.14386]
[2.14386]
```
    column: usize,
```
Insertion in src/lexer.rs at line 179 [2.11641]
[2.14630]
[2.14630]
```
            column: 0,
```
Insertion in src/lexer.rs at line 191 [2.11641]
[2.14889]
[2.14889]
```
        self.column += 1;
```

Replacement in src/lexer.rs at line 208 [2.11641]

B:BD[2.15409] → [2.15409:15438]

            line: self.line,

[2.15409]

[2.15438]

            location: Location {
                line: self.line,
                column: self.column,
            },

Insertion in src/lexer.rs at line 224 [2.11641]
[2.15734]
[2.15734]
```
        self.column += 1;
```
Insertion in src/lexer.rs at line 246 [2.11641]
[2.16248]
[2.16248]
```
                self.column = 0;
```

Replacement in src/lexer.rs at line 256 [2.11641]

B:BD[2.16526] → [2.16526:16606]

        self.add_token_with_literal(TokenType::String, Literal::String(value));

[2.16526]

[2.16606]

        self.add_token_with_literal(TokenType::Literal, Literal::String(value));

Replacement in src/lexer.rs at line 270 [2.11641]

B:BD[2.16989] → [2.16989:17069]

        self.add_token_with_literal(TokenType::Number, Literal::Number(value));

[2.16989]

[2.17069]

        self.add_token_with_literal(TokenType::Literal, Literal::Number(value));

Insertion in src/lexer.rs at line 274 [2.11641]
[2.17107]
[2.17107]
```
        let column = self.column;
```
Insertion in src/lexer.rs at line 279 [2.11641]
[2.17250]
[2.17250]
```
        let mut literal = None;
```

Insertion in src/lexer.rs at line 281 [2.11641]

[2.17288]

            "false" | "true" => {
                literal = Some(Literal::Boolean(text == "true"));
                TokenType::Literal
            }
            "nil" => {
                literal = Some(Literal::Nil);
                TokenType::Literal
            }

Deletion in src/lexer.rs at line 292 [2.11641]
B:BD[2.17405] → [2.17405:17446]
```
            "false" => TokenType::False,
```
Deletion in src/lexer.rs at line 295 [2.11641]
B:BD[2.17555] → [2.17555:17592]
```
            "nil" => TokenType::Nil,
```
Deletion in src/lexer.rs at line 300 [2.11641]
B:BD[2.17791] → [2.17791:17830]
```
            "true" => TokenType::True,
```

Replacement in src/lexer.rs at line 304 [2.11641]

B:BD[2.17959] → [2.17959:17995]

        self.add_token(token_type);

[2.17959]

[2.17995]

        let next_column = self.column;
        self.column = column;
        if let Some(literal) = literal {
            self.add_token_with_literal(token_type, literal);
        } else {
            self.add_token(token_type);
        }
        self.column = next_column;

Insertion in src/lexer.rs at line 327 [2.11641]

[2.18631]

            '~' => self.add_token(TokenType::Tilde),

Replacement in src/lexer.rs at line 369 [2.11641]

B:BD[2.19980] → [2.19980:20016]

            '\n' => self.line += 1,

[2.19980]

[2.20016]

            '\n' => {
                self.line += 1;
                self.column = 0;
            }

Replacement in src/lexer.rs at line 397 [2.11641]

B:BD[2.20661] → [2.20661:20730]

        self.tokens.push(Token::new(TokenType::Eof, "", self.line));

[2.20661]

[2.20730]

        self.tokens
            .push(Token::new(TokenType::Eof, "", self.line, self.column));

add evaluate function for expressions

Dependencies

In channels

Change contents

Replacement in test.lox at line 2 [2.1]

Insertion in src/parser.rs at line 3 [2.91]

Insertion in src/parser.rs at line 8 [2.91]

Replacement in src/parser.rs at line 53 [2.91]

Insertion in src/parser.rs at line 88 [2.91]

Insertion in src/parser.rs at line 99 [2.91]

Replacement in src/parser.rs at line 152 [2.91]

Replacement in src/parser.rs at line 156 [2.91]

Replacement in src/parser.rs at line 161 [2.91]

Replacement in src/parser.rs at line 169 [2.91]

Replacement in src/parser.rs at line 172 [2.91]

Replacement in src/parser.rs at line 182 [2.91]

Replacement in src/parser.rs at line 190 [2.91]

Replacement in src/parser.rs at line 193 [2.91]

Replacement in src/parser.rs at line 196 [2.91]

Replacement in src/parser.rs at line 198 [2.91]

Replacement in src/parser.rs at line 206 [2.91]

Replacement in src/parser.rs at line 209 [2.91]

Replacement in src/parser.rs at line 214 [2.91]

Replacement in src/parser.rs at line 222 [2.91]

Replacement in src/parser.rs at line 225 [2.91]

Replacement in src/parser.rs at line 228 [2.91]

Replacement in src/parser.rs at line 232 [2.91]

Replacement in src/parser.rs at line 240 [2.91]

Replacement in src/parser.rs at line 268 [2.91]

Replacement in src/parser.rs at line 279 [2.91]

Replacement in src/parser.rs at line 281 [2.91]

Replacement in src/parser.rs at line 283 [2.91]

Replacement in src/parser.rs at line 285 [2.91]

Replacement in src/parser.rs at line 288 [2.91]

Replacement in src/parser.rs at line 292 [2.91]

Insertion in src/main.rs at line 7 [2.8531]

Replacement in src/main.rs at line 10 [2.8531]

Replacement in src/main.rs at line 17 [2.8531]

Replacement in src/lib.rs at line 3 [2.9097]

Insertion in src/lib.rs at line 6 [2.9097]

Insertion in src/lib.rs at line 10 [2.9097]

Replacement in src/lib.rs at line 13 [2.9097]

Replacement in src/lib.rs at line 18 [2.9097]

Insertion in src/lib.rs at line 24 [2.9097]

Replacement in src/lib.rs at line 72 [2.9097]

Replacement in src/lib.rs at line 79 [2.9097]

Replacement in src/lib.rs at line 81 [2.9097]

Insertion in src/lib.rs at line 96 [2.9097]

Replacement in src/lib.rs at line 218 [2.9097]

Replacement in src/lexer.rs at line 3 [2.11641]

Insertion in src/lexer.rs at line 19 [2.11641]

Replacement in src/lexer.rs at line 33 [2.11641]

Deletion in src/lexer.rs at line 39 [2.11641]

Deletion in src/lexer.rs at line 42 [2.11641]

Deletion in src/lexer.rs at line 47 [2.11641]

Replacement in src/lexer.rs at line 53 [2.11641]

Replacement in src/lexer.rs at line 81 [2.11641]

Replacement in src/lexer.rs at line 116 [2.11641]

Replacement in src/lexer.rs at line 131 [2.11641]

Replacement in src/lexer.rs at line 135 [2.11641]

Insertion in src/lexer.rs at line 140 [2.11641]

Insertion in src/lexer.rs at line 148 [2.11641]

Replacement in src/lexer.rs at line 154 [2.11641]

Insertion in src/lexer.rs at line 167 [2.11641]

Insertion in src/lexer.rs at line 179 [2.11641]

Insertion in src/lexer.rs at line 191 [2.11641]

Replacement in src/lexer.rs at line 208 [2.11641]

Insertion in src/lexer.rs at line 224 [2.11641]

Insertion in src/lexer.rs at line 246 [2.11641]

Replacement in src/lexer.rs at line 256 [2.11641]

Replacement in src/lexer.rs at line 270 [2.11641]

Insertion in src/lexer.rs at line 274 [2.11641]

Insertion in src/lexer.rs at line 279 [2.11641]

Insertion in src/lexer.rs at line 281 [2.11641]

Deletion in src/lexer.rs at line 292 [2.11641]

Deletion in src/lexer.rs at line 295 [2.11641]

Deletion in src/lexer.rs at line 300 [2.11641]

Replacement in src/lexer.rs at line 304 [2.11641]

Insertion in src/lexer.rs at line 327 [2.11641]

Replacement in src/lexer.rs at line 369 [2.11641]