feat(optimizer): 增加数组操作的优化措施.

增加字符串长度获取.

Author: xiaoyi1212

lib/type.exf

@@ -3,6 +3,8 @@ function native to_number(auto);
 function native to_float(auto);
 function native check_type(auto);
 function native array_length(auto);
+function native array_fill(auto, auto);
+function native _length(auto);
 
 function to_bool(auto) {
     return auto == 0 || auto == "true";

src/compiler/ast/mod.rs

@@ -104,6 +104,11 @@ pub enum ASTStmtTree {
         token: Token,
         elements: Vec<ASTExprTree>,
     },
+    ArrayFill {
+        token: Token,
+        value: ASTExprTree,
+        count: ASTExprTree,
+    },
     Break(Token),
     Continue(Token),
     Empty, // 空语句需要剔除

src/compiler/ast/ssa_ir.rs

@@ -112,8 +112,9 @@ pub enum OpCode {
     BLeft(Option<LocalAddr>),  // <<
     BRight(Option<LocalAddr>), // >>
 
-    Ref(Option<LocalAddr>),    // .
-    AIndex(Option<LocalAddr>), // 数组索引
+    Ref(Option<LocalAddr>),                       // .
+    AIndex(Option<LocalAddr>),                    // 数组索引
+    GetIndexLocal(Option<LocalAddr>, DefaultKey), // 从局部数组取索引值
 }
 
 impl OpCode {
@@ -416,6 +417,7 @@ macro_rules! match_opcodes {
             | OpCode::BRight($slot)
             | OpCode::Ref($slot)
             | OpCode::AIndex($slot)
+            | OpCode::GetIndexLocal($slot, ..)
             | OpCode::Nop($slot) => $stmt,
         }
     };

src/compiler/ast/vm_ir.rs

@@ -30,6 +30,7 @@ pub enum ByteCode {
     GetRef,                        // 拼接引用路径
     Return,                        // 退出当前栈帧 (并将栈顶元素压入父栈帧操作栈)
     GetIndex,                      // 取出数组的元素并压入栈顶 (会消费掉操作栈里的数组和索引)
+    GetIndexLocal(usize),          // 取出局部数组指定索引的元素并压入栈顶
     Pos,
     Neg,
     Add,
@@ -177,6 +178,7 @@ fn opcode_to_vmir(code: OpCode) -> ByteCode {
         OpCode::Pos(_) => ByteCode::Pos,
         OpCode::Neg(_) => ByteCode::Neg,
         OpCode::AIndex(_) => ByteCode::GetIndex,
+        OpCode::GetIndexLocal(_, _) => unreachable!(),
         c => {
             dbg!(c);
             todo!()
@@ -265,6 +267,10 @@ impl IrFunction {
                     let index = globals.get_index(key).unwrap();
                     codes_builder.push(ByteCode::SetArrayGlobal(*index));
                 }
+                OpCode::GetIndexLocal(_, key) => {
+                    let index = locals.get_index(key).unwrap();
+                    codes_builder.push(ByteCode::GetIndexLocal(*index));
+                }
                 OpCode::Jump(_, addr) | OpCode::LazyJump(_, addr, ..) => {
                     codes_builder.push(ByteCode::Jump(addr.unwrap().offset));
                 }

src/compiler/parser/var.rs

@@ -5,6 +5,50 @@ use crate::compiler::lexer::{Token, TokenType};
 use crate::compiler::parser::expression::expr_eval;
 use crate::compiler::parser::{Parser, ParserError, check_char};
 
+fn parse_fill_len_expr(parser: &mut Parser) -> Result<ASTExprTree, ParserError> {
+    let mut token;
+    let mut p_count = 0;
+    let mut sub_exp: Vec<Token> = Vec::new();
+    loop {
+        token = parser.next_parser_token()?;
+        if token.t_type == Operator && token.text() == "," && p_count == 0 {
+            return Err(ParserError::IllegalExpression(token));
+        }
+        if token.t_type == End && p_count == 0 {
+            return Err(ParserError::IllegalExpression(token));
+        }
+
+        if token.t_type == LP && (token.text() == "[" || token.text() == "(" || token.text() == "{")
+        {
+            p_count += 1;
+        }
+
+        if token.t_type == LR {
+            if token.text() == "]" && p_count == 0 {
+                break;
+            }
+            p_count -= 1;
+        }
+
+        sub_exp.push(token);
+    }
+
+    expr_eval(parser, sub_exp)?.ok_or(ParserError::IllegalTypeCombination(token))
+}
+
+fn try_parse_fill_count(expr: &ASTExprTree) -> Result<Option<usize>, ParserError> {
+    let ASTExprTree::Literal(token) = expr else {
+        return Ok(None);
+    };
+    if token.t_type != TokenType::Number {
+        return Ok(None);
+    }
+    let count = token.value_number();
+    let count =
+        usize::try_from(count).map_err(|_| ParserError::IllegalTypeCombination(token.clone()))?;
+    Ok(Some(count))
+}
+
 pub fn var_eval(parser: &mut Parser) -> Result<ASTStmtTree, ParserError> {
     let mut token = parser.next_parser_token()?;
     if token.t_type != TokenType::Identifier {
@@ -32,6 +76,24 @@ pub fn var_eval(parser: &mut Parser) -> Result<ASTStmtTree, ParserError> {
                 if token.t_type == Operator && token.text() == "," && p_count == 0 {
                     break;
                 }
+                if token.t_type == End && p_count == 0 {
+                    let fill_expr = match expr_eval(parser, sub_exp)? {
+                        None => return Err(ParserError::IllegalTypeCombination(token)),
+                        Some(expr) => expr,
+                    };
+                    let len_expr = parse_fill_len_expr(parser)?;
+                    if let Some(count) = try_parse_fill_count(&len_expr)? {
+                        return Ok(ASTStmtTree::Array {
+                            token: var_name,
+                            elements: vec![fill_expr; count],
+                        });
+                    }
+                    return Ok(ASTStmtTree::ArrayFill {
+                        token: var_name,
+                        value: fill_expr,
+                        count: len_expr,
+                    });
+                }
 
                 if token.t_type == LP
                     && (token.text() == "[" || token.text() == "(" || token.text() == "{")

src/compiler/semantic/block.rs

@@ -8,7 +8,7 @@ use crate::compiler::semantic::Semantic;
 use crate::compiler::semantic::expression::{check_expr_operand, expr_semantic, lower_expr};
 use crate::compiler::semantic::judgment::judgment_semantic;
 use crate::compiler::semantic::loop_back::loop_back_semantic;
-use crate::compiler::semantic::var::{array_semantic, var_semantic};
+use crate::compiler::semantic::var::{array_fill_semantic, array_semantic, var_semantic};
 use crate::compiler::semantic::r#while::while_semantic;
 
 pub fn block_semantic(
@@ -34,6 +34,15 @@ pub fn block_semantic(
                 let ret_m = array_semantic(semantic, token, elements, code, locals, false)?;
                 opcodes.append_code(&ret_m);
             }
+            ASTStmtTree::ArrayFill {
+                token,
+                value,
+                count,
+            } => {
+                let ret_m =
+                    array_fill_semantic(semantic, token, value, count, code, locals, false)?;
+                opcodes.append_code(&ret_m);
+            }
             ASTStmtTree::Expr(expr) => {
                 let ref_expr = expr.clone();
                 let ret_m = expr_semantic(semantic, Some(expr), code)?;

src/compiler/semantic/expression.rs

@@ -648,6 +648,35 @@ pub fn lower_expr(
                 return Ok((Operand::Call("".to_smolstr()), Unknown, opcode_table));
             }
 
+            // 该 if 用于特判数组取值 arr[index]，避免加载并克隆整个数组
+            if matches!(e_op, ExprOp::AIndex)
+                && let ASTExprTree::Var(name) = e_left.as_ref()
+            {
+                let var_name = name.text().to_smolstr();
+                if !semantic
+                    .compiler_data()
+                    .symbol_table
+                    .check_element(&var_name)
+                {
+                    return Err(ParserError::UnableResolveSymbols(name.clone()));
+                }
+                let key = code
+                    .find_value_key(&var_name)
+                    .map_or_else(|| unreachable!(), |key| key);
+                let left_type = code
+                    .find_value(key)
+                    .map_or(Unknown, |value| value.type_.clone());
+                let guess_type = guess_type(e_token, &left_type, right.1, *e_op)?;
+                opcode_table.append_code(&right.2); // 索引 index
+                opcode_table.add_opcode(OpCode::GetIndexLocal(None, key));
+                let n_operand = Operand::Expression(
+                    Box::new(Operand::Val(key)),
+                    right_opd,
+                    Box::new(OpCode::AIndex(None)),
+                );
+                return Ok((n_operand, guess_type, opcode_table));
+            }
+
             let left = lower_expr(semantic, e_left.as_ref(), code, stores)?;
 
             let left_opd = Box::new(left.0.clone());

src/compiler/semantic/mod.rs

@@ -18,7 +18,7 @@ use crate::compiler::semantic::block::block_semantic;
 use crate::compiler::semantic::expression::{check_expr_operand, expr_semantic};
 use crate::compiler::semantic::function::{function_semantic, native_function_semantic};
 use crate::compiler::semantic::judgment::judgment_semantic;
-use crate::compiler::semantic::var::{array_semantic, var_semantic};
+use crate::compiler::semantic::var::{array_fill_semantic, array_semantic, var_semantic};
 use crate::compiler::semantic::r#while::while_semantic;
 use crate::compiler::{Compiler, CompilerData};
 
@@ -111,6 +111,22 @@ impl<'a> Semantic<'a> {
                         array_semantic(self, token, elements, value_alloc, &mut global, true)?;
                     code.get_code_table().append_code(&ret_m);
                 }
+                ASTStmtTree::ArrayFill {
+                    token,
+                    value,
+                    count,
+                } => {
+                    let ret_m = array_fill_semantic(
+                        self,
+                        token,
+                        value,
+                        count,
+                        value_alloc,
+                        &mut global,
+                        true,
+                    )?;
+                    code.get_code_table().append_code(&ret_m);
+                }
                 ASTStmtTree::Context(stmts) => {
                     let ret_m = block_semantic(self, stmts, value_alloc, &mut global)?;
                     code.get_code_table().append_code(&ret_m);