Advice for improving the performance of my grammar

[rscarson]

My interpreter is working, and I'm now looking towards improving performance

Any obvious ways I can improve parsing speed for the grammar below?

SCRIPT = { 
    LINE* ~ &EOI 
} 

LINE = _{ 
    | WHITESPACE* ~ STATEMENT ~ (EOL | &EOI) 
    | WHITESPACE* ~ (EOL | INLINE_COMMENT) 
} 

// 
// Tokenizer configuration 
// 

INLINE_COMMENT = @{"//" ~ (!EOL ~ ANY)* ~ (&EOL | &EOI)} 
BLOCK_COMMENT = @{"/*" ~ (!"*/" ~ ANY)* ~ "*/"} 
COMMENT = _{INLINE_COMMENT | BLOCK_COMMENT} 

WHITESPACE = _{" " | "\t" | "\\" ~ EOL | COMMENT} 
EOL = _{NEWLINE | ";"} 

// 
// Top of expression tree 
// 

STATEMENT = _{ 
    | FUNCTION_ASSIGNMENT_STATEMENT 
    | EXPR 
} 

function_name = @{symbol_at? ~ identifier} 
FUNCTION_ASSIGNMENT_STATEMENT = { 
    | EOL* ~ function_name ~ EOL* ~  
        symbol_openround ~ EOL* ~  
            (function_argument ~ EOL* ~ (symbol_comma ~ EOL* ~ function_argument ~ EOL*)* ~ symbol_comma? ~ EOL*)? ~  
        symbol_closeround ~ (EOL* ~ function_typespec)? ~ EOL* ~  
        symbol_eq ~ EOL* ~ BLOCK 
} 
        function_typespec = {symbol_colon ~ EOL* ~ identifier} 
        function_argument = {identifier ~ EOL* ~ (symbol_colon ~ EOL* ~ identifier)?} 

BLOCK = { 
    | symbol_opencurly ~ LINE* ~ (STATEMENT)? ~ EOL? ~ symbol_closecurly 
    | EXPR 
} 

// 
// Expressions tree 
// 

EXPR = { 
    prefix_op? ~ EOL* ~ TERM ~ postfix_operation* ~ ( EOL* ~ infix_op ~ prefix_op? ~ EOL* ~ TERM ~ postfix_operation*)* 
} 
    // 
    // Postfix 
    postfix_operation = _{POSTFIX_DECORATE | POSTFIX_INDEX | POSTFIX_CALL | postfix_arith} 
        POSTFIX_DECORATE = {"@" ~ EOL* ~ identifier} 
        POSTFIX_EMPTYINDEX = {(symbol_opensquare ~ EOL* ~ symbol_closesquare)} 
        POSTFIX_INDEX = {((symbol_opensquare ~ EOL* ~ EXPR ~ EOL* ~ symbol_closesquare) | POSTFIX_EMPTYINDEX)+} 
        POSTFIX_CALL = {POSTFIX_NORMALMODE | POSTFIX_OBJECTMODE} 
            postfixcall_args = _{(EXPR ~ EOL* ~ symbol_comma ~ EOL*)* ~ EXPR ~ EOL* ~ symbol_comma?} 
            POSTFIX_NORMALMODE = {symbol_openround ~ EOL* ~ postfixcall_args? ~ EOL* ~ symbol_closeround} 
            POSTFIX_OBJECTMODE = {"." ~ EOL* ~ identifier ~ EOL* ~ POSTFIX_NORMALMODE} 
        postfix_arith = _{POSTFIX_INC | POSTFIX_DEC} 
            POSTFIX_INC = {"++"} 
            POSTFIX_DEC = {"--"} 

    // 
    // Prefix 
    prefix_op = _{PREFIX_DEL | prefix_arith | PREFIX_BOOL_NOT | PREFIX_BIT_NOT} 
        PREFIX_DEL = @{del_keyword ~ WHITESPACE* ~ symbol_at?} 
            del_keyword = @{("delete" | "del" | "unset") ~ !ASCII_ALPHA} 
        PREFIX_BOOL_NOT = {"!" ~ !"="} 
        PREFIX_BIT_NOT = {"~" ~ !"="} 
        prefix_arith = _{PREFIX_INC | PREFIX_DEC | PREFIX_NEG} 
            PREFIX_NEG = {"-" ~ !"="} 
            PREFIX_INC = {"++"} 
            PREFIX_DEC = {"--"} 

    // 
    // Infix 
    infix_op = _{OP_BOOL_OR | OP_BOOL_AND | assignment_infix_op | bitwise_infix_op | bool_infix_op | arithmetic_infix_op | OP_ASSIGN | match_infix_op | OP_RANGE | OP_CAST | OP_TERNARY} 
        // 
        // Assignment 
        assignment_infix_op = _{ 
            | OP_ASSIGN_ADD | OP_ASSIGN_SUB | OP_ASSIGN_POW | OP_ASSIGN_MUL | OP_ASSIGN_DIV | OP_ASSIGN_MOD 
            | OP_BASSIGN_AND | OP_BASSIGN_OR 
            | OP_ASSIGN_AND | OP_ASSIGN_XOR | OP_ASSIGN_OR | OP_ASSIGN_SL | OP_ASSIGN_SR 
        } 
            OP_ASSIGN_ADD = {"+="} 
            OP_ASSIGN_SUB = {"-="} 
            OP_ASSIGN_POW = {"**="} 
            OP_ASSIGN_MUL = {"*="} 
            OP_ASSIGN_DIV = {"/="} 
            OP_ASSIGN_MOD = {"%="} 
            OP_BASSIGN_AND = {"&&="} 
            OP_BASSIGN_OR = {"||="} 
            OP_ASSIGN_OR = {"|="} 
            OP_ASSIGN_AND = {"&="} 
            OP_ASSIGN_XOR = {"^="} 
            OP_ASSIGN_SL = {"<<="} 
            OP_ASSIGN_SR = {">>="} 
            OP_ASSIGN = {"="} 

        // 
        // Boolean 
        bool_infix_op = _{OP_BOOL_OR | OP_BOOL_AND | OP_BOOL_EQ | OP_BOOL_NE | OP_BOOL_LE | OP_BOOL_GE | OP_BOOL_LT | OP_BOOL_GT} 
            OP_BOOL_OR = {"||"} 
            OP_BOOL_AND = {"&&"} 
            OP_BOOL_EQ = {"=="} 
            OP_BOOL_NE = {"!="} 
            OP_BOOL_LE = {"<="} 
            OP_BOOL_GE = {">="} 
            OP_BOOL_LT = {"<"} 
            OP_BOOL_GT = {">"} 

        // 
        // Bitwise 
        bitwise_infix_op = _{OP_BIT_OR | OP_BIT_XOR | OP_BIT_AND | OP_BIT_SL | OP_BIT_SR} 
            OP_BIT_OR = {"|"} 
            OP_BIT_XOR = {"^"} 
            OP_BIT_AND = {"&"} 
            OP_BIT_SL = {"<<"} 
            OP_BIT_SR = {">>"} 

        // 
        // Arithmetic 
        arithmetic_infix_op = _{OP_ADD | OP_SUB | OP_POW | OP_DIV | OP_MOD | OP_MUL} 
            OP_ADD = {"+"} 
            OP_SUB = {"-"} 
            OP_MUL = {"*"} 
            OP_DIV = {"/"} 
            OP_MOD = {"%"} 
            OP_POW = {"**"} 

        // 
        // Match 
        match_infix_op = _{OP_MATCH_CONTAINS | OP_MATCH_MATCHES | OP_MATCH_IS | OP_MATCH_STARTSWITH | OP_MATCH_ENDSWITH} 
            OP_MATCH_CONTAINS = @{"contains" ~ !ASCII_ALPHA} 
            OP_MATCH_MATCHES = @{"matches" ~ !ASCII_ALPHA} 
            OP_MATCH_IS = @{"is" ~ !ASCII_ALPHA} 
            OP_MATCH_STARTSWITH = @{("startswith" | "starts_with") ~ !ASCII_ALPHA} 
            OP_MATCH_ENDSWITH = @{("endswith" | "ends_with") ~ !ASCII_ALPHA} 

        // 
        // Other 
        OP_RANGE = {".."} 
        OP_CAST = @{"as" ~ !ASCII_ALPHA} 
        OP_TERNARY = {symbol_questionmark ~ EOL* ~ EXPR ~ EOL* ~ symbol_colon} 

// 
// Term 
// The basic building block of the language 
// 

TERM = _{ 
    // These can be identified by the first character 
    | symbol_openround ~ EXPR ~ symbol_closeround 
    | ARRAY_TERM 
    | OBJECT_TERM 

    // These can be identified by the first word 
    | KEYWORD_EXPRESSION 

    // Value primitives 
    | ATOMIC_VALUE 

    // Error catcher 
    | ERROR 
} 

// 1 + 2 [2] ? 3 : 4 
// Keyword expressions 
// 

KEYWORD_EXPRESSION = _ { 
    | SKIP_KEYWORD | BREAK_KEYWORD | RETURN_EXPRESSION 
    | FOR_LOOP_EXPRESSION | SWITCH_EXPRESSION | IF_EXPRESSION 
} 

    SKIP_KEYWORD = {"skip" | "continue"} 
    BREAK_KEYWORD = {"break"} 

    RETURN_EXPRESSION = { "return" ~ EOL* ~ BLOCK } 

    FOR_LOOP_EXPRESSION = { "for" ~ EOL* ~ (identifier ~ EOL* ~ "in" ~ EOL*)? ~ EXPR ~ EOL* ~ ("do" | &symbol_opencurly) ~ EOL* ~ BLOCK ~ (EOL* ~ for_conditional)? } 
        for_conditional = {"if" ~ EOL* ~ EXPR} 

    SWITCH_EXPRESSION = { "match" ~ EOL* ~ EXPR ~ EOL* ~ symbol_opencurly ~ EOL* ~ (switch_case ~ EOL* ~ symbol_comma ~ EOL*)* ~ switch_case ~ EOL* ~ symbol_comma? ~ EOL* ~ symbol_closecurly } 
        switch_case = _{ ATOMIC_VALUE ~ EOL* ~ symbol_arrow ~ EOL* ~ BLOCK } 

    IF_EXPRESSION = { if_block ~ ("else" ~ EOL* ~ if_block ~ EOL*)* ~ ("else" ~ EOL* ~ BLOCK)? } 
        if_block = _{ "if" ~ EXPR ~ EOL* ~ ("then" | &symbol_opencurly) ~ EOL* ~ BLOCK ~ EOL* } 

    ARRAY_TERM = { array_symbol_opensquare ~ EOL* ~ ((EXPR) ~ (EOL* ~ symbol_comma ~ EOL* ~ (EXPR) ~ EOL*)* ~ symbol_comma? ~ EOL*)? ~ symbol_closesquare } 
        array_symbol_opensquare = {"["} 
    OBJECT_TERM = { 
        symbol_opencurly ~ EOL* ~ ((object_keyvalue_pair ~ EOL* ~ symbol_comma ~ EOL*)* ~ object_keyvalue_pair ~ EOL*)? ~ symbol_comma? ~ EOL* ~ symbol_closecurly 
        | symbol_opencurly ~ EOL* ~ symbol_closecurly 
    } 
        object_keyvalue_pair = _{(EXPR) ~ symbol_colon ~ (EXPR)} 

// 
// Value Literals 
// Single literals of the various types 
// 

ATOMIC_VALUE = _{ 
    | currency_literal | fixed_literal 
    | sci_literal | float_literal 
    | int_literal 
    | bool_literal | string_literal 
    | regex_literal 
    | identifier 
    | const_literal 
} 

    fixed_literal = @{ 
        ASCII_DIGIT+ ~ ("." ~ ASCII_DIGIT+)? ~ ("D" | "d" | "F" | "f") 
    } 

    // Fixed-point currency values 
    // Symbols from [polyvalue::CurrencyInner] 
    currency_literal = { 
        currency_symbol ~ (float_literal | dec_literal) 
        | (float_literal | dec_literal) ~ (currency_symbol | currency_suffix) 
    } 
        currency_symbol = @{ 
            "$" | "¢" | "£" | "¤" | "¥" | "֏" | "؋" | "߾" | "߿" | "৲" | "৳" | "৻" | "૱" | "௹" | "฿" | "៛" | "₠" | "₡" | 
            "₢" | "₣" | "₤" | "₥" | "₦" | "₧" | "₨" | "₩" | "₪" | "₫" | "€" | "₭" | "₮" | "₯" | "₰" | "₱" | "₲" | "₳" | 
            "₴" | "₵" | "₶" | "₷" | "₸" | "₹" | "₺" | "₻" | "₼" | "₽" | "₾" | "₿" | "꠸" | "﷼" | "﹩" | "＄" | "￠" | 
            "￡" | "￥" | "￦" 
        } 
        currency_suffix = @{ 
            ^"USD" | ^"US$" | ^"CAD" | ^"C$" | ^"AUD" | ^"A$" | ^"NZD" | ^"NZ$" | ^"HKD" | ^"HK$" | ^"SGD" | ^"S$" | ^"EUR" | 
            "JPY" | ^"CNY" | ^"CN¥" | ^"GBP" | ^"NOK" | ^"kr" | ^"SEK" | ^"kr" | ^"DKK" | ^"kr" | ^"CHF" | ^"Fr." | ^"ISK" | 
            "kr" | ^"CZK" | ^"Kč" | ^"HUF" | ^"Ft" | ^"PLN" | ^"zł" | ^"HRK" | ^"kn" | ^"RUB" | ^"TRY" | ^"BRL" | ^"R$" | ^"INR" | 
            "IDR" | ^"Rp" | ^"ILS" | ^"ZAR" | ^"SAR" | ^"AED" | ^"KRW" | ^"VND" | ^"PHP" | ^"MXN" | ^"THB" | ^"MYR" | ^"RM" | 
            "TWD" | ^"NT$" | ^"NGN" | ^"CLP" | ^"CL$" | ^"ARS" | ^"AR$" | ^"COP" | ^"CO$" | ^"PEN" | ^"S/." | ^"DOP" | ^"RD$" 
        } 

    // Floating-point literals 
    sci_literal = @{(float_literal | dec_literal) ~ ^"e" ~ ("+"|"-")? ~ ASCII_DIGIT+} 
    float_literal = @{dec_literal? ~ "." ~ ASCII_DIGIT+} 

    const_literal = @{"pi" | "e" | "tau" | "nil"} 

    // Integer literals 
    int_literal = {(hex_literal | bin_literal | oct_literal | dec_literal) ~ sized_literal_suffix?} 
        dec_literal = @{int_sep | ASCII_DIGIT+} 
            int_sep = _{ASCII_DIGIT{1,3} ~ ("_" ~ ASCII_DIGIT{3})+} 

        hex_literal = @{(^"0x") ~ ('a'..'f' | 'A'..'F' | ASCII_DIGIT | "_")+} 
        bin_literal = @{(^"0b") ~ ('0'..'1' | "_")+} 
        oct_literal = @{(^"0o" | "0") ~ ('0'..'7' | "_")+}    

        sized_literal_suffix = _{intsize_u8 | intsize_i8 | intsize_u16 | intsize_i16 | intsize_u32 | intsize_i32 | intsize_u64 | intsize_i64} 
            intsize_u8 = {"u8"} intsize_i8 = {"i8"} 
            intsize_u16 = {"u16"} intsize_i16 = {"i16"} 
            intsize_u32 = {"u32"} intsize_i32 = {"i32"} 
            intsize_u64 = {"u64"} intsize_i64 = {"i64"} 

    // Other literals 
    bool_literal = @{^"true" | ^"false"} 
    string_literal = @{("\"" ~ ("\\"~ANY | (!"\"" ~ ANY))* ~ "\"") | ("\'" ~ ("\\"~ANY | (!"\'" ~ ANY))* ~ "\'")} 

    regex_literal = @{ 
        "/" ~ (!"/" ~ ANY | "\\/")* ~ "/" ~ ("i" | "g" | "m" | "s" | "u" | "y")* 
    } 

    identifier = @{!reserved_words ~ (ASCII_ALPHA|"_") ~ (ASCII_ALPHANUMERIC|"_")*} 
        reserved_words = { 
            ("pi" | "e" | "tau" | "nil" | "true" | "false" 
            | "if" | "then" | "else" | "for" | "in" | "do" | "match" 
            | "return" 
            | prefix_op | infix_op 
            | SKIP_KEYWORD | BREAK_KEYWORD) ~ !(ASCII_ALPHANUMERIC|"_") 
        } 

// 
// Errors 
// 

ERROR = _{ 
    | UNTERMINATED_BLOCK_COMMENT 
    | UNTERMINATED_STRING_LITERAL 

    | UNCLOSED_BRACKET 
    | UNCLOSED_BRACE 
    | UNCLOSED_PAREN 
    | MISSING_LINEBREAK 
} 

UNTERMINATED_BLOCK_COMMENT = @{"/*" ~ (!"*/" ~ ANY)*} 
UNTERMINATED_STRING_LITERAL = @{"\"" ~ (!EOL ~ ANY)*} 
UNCLOSED_BRACKET = @{"[" ~ (!symbol_closesquare ~ ANY)*} 
UNCLOSED_BRACE = @{symbol_opencurly ~ (!symbol_closecurly ~ ANY)*} 
UNCLOSED_PAREN = @{symbol_openround ~ (!symbol_closeround ~ ANY)*} 
MISSING_LINEBREAK = @{"\\" ~ !EOL} 

// 
// Symbols 
// 

symbol_questionmark = {"?"} 
symbol_colon = {":"} 
symbol_comma = {","} 
symbol_arrow = {"=>"} 
symbol_at = {"@"} 
symbol_eq = {"="} 

symbol_opencurly = {"{"} 
symbol_closecurly = {"}"} 
symbol_opensquare = {"["} 
symbol_closesquare = {"]"} 
symbol_openround = {"("} 
symbol_closeround = {")"}

[rscarson]

Note that the manual implementation of EOL whitespace is because I could not get it working as intended - there is a performance penalty (~10-15ms in my benchmarks)

I wanted expressions to be separated by either EOL or ';', work operators and expressions able to span lines