fix(executor): 修复赋值运算符的行为, 修复类型检查器的错误判断问题.

补充常量折叠优化器的计算.

Author: xiaoyi1212

Cargo.toml

@@ -11,6 +11,10 @@ expect-test = "1.5.1"
 linked-hash-map = "0.5.6"
 crossbeam-channel = "0.5.15"
 
+[lib]
+name = "openex"
+path = "src/lib.rs"
+
 [profile.release]
 debug = false
 strip = true

src/compiler/ast/ssa_ir.rs

@@ -48,6 +48,7 @@ pub struct Value {
 pub enum OpCode {
     // Option<LocalAddr> 为各 IR 的逻辑地址
     LoadGlobal(Option<LocalAddr>, DefaultKey, Operand), // 栈顶元素加载到全局变量
+    StoreGlobal(Option<LocalAddr>, DefaultKey, Operand), // 将一个全局变量加载到栈顶
     LoadLocal(Option<LocalAddr>, DefaultKey, Operand),  // 栈顶元素加载到局部变量
     StoreLocal(Option<LocalAddr>, DefaultKey, Operand), // 将一个变量加载到栈顶
     Push(Option<LocalAddr>, Operand),                   // 将值压入操作栈
@@ -214,14 +215,14 @@ pub struct LocalMap {
 
 impl LocalMap {
     pub fn new() -> LocalMap {
-        Self  {
+        Self {
             locals: BTreeMap::new(),
             now_index: 0,
         }
     }
 
     pub fn add_local(&mut self, local: DefaultKey) -> usize {
-        self.locals.insert(local,self.now_index);
+        self.locals.insert(local, self.now_index);
         let ret_m = self.now_index;
         self.now_index += 1;
         ret_m
@@ -237,7 +238,7 @@ pub struct Function {
     pub(crate) name: SmolStr,
     pub(crate) args: usize,
     pub(crate) codes: Option<OpCodeTable>, // 为 None 代表本地方法实现
-    pub(crate) locals: LocalMap,    // 局部变量表映射
+    pub(crate) locals: LocalMap,           // 局部变量表映射
 }
 
 #[derive(Debug, Clone)]
@@ -305,6 +306,7 @@ macro_rules! mathch_opcodes {
     ($expr: expr,$slot:ident,$stmt: expr) => {
         match $expr {
             OpCode::LoadGlobal($slot, ..)
+            | OpCode::StoreGlobal($slot, ..)
             | OpCode::LoadLocal($slot, ..)
             | OpCode::StoreLocal($slot, ..)
             | OpCode::Push($slot, ..)

src/compiler/ast/vm_ir.rs

@@ -108,6 +108,7 @@ fn opcode_to_vmir(code: OpCode) -> ByteCode {
         OpCode::Equ(_) => ByteCode::Equ,
         OpCode::Call(_, _imm) => ByteCode::Call,
         OpCode::Ref(_) => ByteCode::GetRef,
+
         c => {
             dbg!(c);
             todo!()
@@ -154,6 +155,14 @@ impl IrFunction {
                     let index = locals.get_index(&key).unwrap();
                     self.codes.push(ByteCode::Store(*index));
                 }
+                OpCode::LoadGlobal(_, key, _) => {
+                    let index = locals.get_index(&key).unwrap();
+                    self.codes.push(ByteCode::LoadGlobal(*index));
+                }
+                OpCode::StoreGlobal(_, key, _) => {
+                    let index = locals.get_index(&key).unwrap();
+                    self.codes.push(ByteCode::StoreGlobal(*index));
+                }
                 c => {
                     self.codes.push(opcode_to_vmir(c));
                 }
@@ -227,6 +236,14 @@ impl VMIRTable {
                     let index = locals.get_index(&key).unwrap();
                     self.codes.push(ByteCode::StoreGlobal(*index));
                 }
+                OpCode::LoadGlobal(_, key, _) => {
+                    let index = locals.get_index(&key).unwrap();
+                    self.codes.push(ByteCode::LoadGlobal(*index));
+                }
+                OpCode::StoreGlobal(_, key, _) => {
+                    let index = locals.get_index(&key).unwrap();
+                    self.codes.push(ByteCode::StoreGlobal(*index));
+                }
                 c => {
                     self.codes.push(opcode_to_vmir(c));
                 }

src/compiler/lexer.rs

@@ -98,7 +98,7 @@ impl Token {
     }
 
     pub fn value_float(&mut self) -> f64 {
-        self.data.parse::<f64>().unwrap()
+        f64::from_str(&self.data).unwrap_or(0.0)
     }
 
     pub fn value_number(&mut self) -> i64 {

src/compiler/mod.rs

@@ -5,7 +5,7 @@ use crate::compiler::lints::Lint;
 use crate::compiler::parser::symbol_table::SymbolTable;
 use crate::compiler::parser::ParserError;
 use std::collections::HashSet;
-use crate::compiler::ast::vm_ir::VMIRTable;
+use std::process::exit;
 
 pub(crate) mod ast;
 pub mod file;
@@ -239,7 +239,7 @@ impl Compiler {
             let vm_ir = file.compiler(&mut compiler).unwrap_or_else(|error| {
                 Self::dump_parser_error(error, file);
                 failed = true;
-                VMIRTable::new()
+                exit(-1);
             });
             if failed {
                 continue;

src/compiler/semantic/expression.rs

@@ -1,7 +1,5 @@
 use crate::compiler::ast::ssa_ir::OpCode::Push;
-use crate::compiler::ast::ssa_ir::ValueGuessType::{
-    Bool, Float, Null, Number, String, This, Unknown,
-};
+use crate::compiler::ast::ssa_ir::ValueGuessType::{Bool, Float, Null, Number, Ref, String, This, Unknown};
 use crate::compiler::ast::ssa_ir::{Code, OpCode, OpCodeTable, Operand, ValueGuessType};
 use crate::compiler::ast::{ASTExprTree, ExprOp};
 use crate::compiler::lexer::{Token, TokenType};
@@ -72,6 +70,9 @@ fn guess_check_type(src: ValueGuessType, args: &[ValueGuessType]) -> bool {
 }
 
 fn check_opts(op: &ExprOp, args: &[ExprOp]) -> bool {
+    if matches!(op, ExprOp::Store | ExprOp::Equ | ExprOp::NotEqu) {
+        return true;
+    }
     for ty in args {
         if op == ty {
             return true;
@@ -115,6 +116,10 @@ fn guess_type(
         return Ok(Unknown);
     }
 
+    if matches!(op, ExprOp::Store) {
+        return Ok(second);
+    }
+
     match first {
         Bool => {
             if guess_check_type(second, &[Bool])
@@ -136,9 +141,9 @@ fn guess_type(
         }
         String => {
             if guess_check_type(second, &[String, Float, Number, Null])
-                && check_opts(op, &[ExprOp::Add, ExprOp::Equ, ExprOp::NotEqu])
+                && check_opts(op, &[ExprOp::Add])
             {
-                if check_opts(op, &[ExprOp::Equ, ExprOp::NotEqu]) {
+                if check_opts(op, &[]) {
                     Ok(Bool)
                 } else {
                     Ok(String)
@@ -248,7 +253,7 @@ fn lower_ref(
 
         if matches!(left_tree, ASTExprTree::Call { .. }) || matches!(left_tree, ASTExprTree::This(_token)) ||
             matches!(left_tree, ASTExprTree::Var(_token)) {
-            let mut table = lower_expr(semantic, left_tree, code)?.2;
+            let mut table = lower_expr(semantic, left_tree, code, None)?.2;
             opcode_table.append_code(&mut table);
         }else {
             unreachable!()
@@ -279,10 +284,24 @@ fn lower_ref(
     Ok((path.finish(), opcode_table))
 }
 
+fn operand_to_guess(operand: Operand) -> ValueGuessType {
+    match operand {
+        Operand::ImmBool(_) => Bool,
+        Operand::Null => Null,
+        Operand::This => This,
+        Operand::ImmNum(_) => Number,
+        Operand::ImmFlot(_) => Float,
+        Operand::ImmStr(_) => String,
+        Operand::Reference(_) => Ref,
+        _=> Unknown,
+    }
+}
+
 pub(crate) fn lower_expr(
     semantic: &mut Semantic,
     expr_tree: &ASTExprTree,
     code: &mut Code,
+    store: Option<Operand>,
 ) -> Result<(Operand, ValueGuessType, OpCodeTable), ParserError> {
     let mut opcode_table = OpCodeTable::new();
     match expr_tree {
@@ -314,13 +333,13 @@ pub(crate) fn lower_expr(
                     Ok((Operand::Null, Null, opcode_table))
                 }
                 _ => {
-                    todo!()
+                    unreachable!()
                 }
             }
         }
         ASTExprTree::Ref(token) => {
             opcode_table.add_opcode(Push(None, Operand::Reference(token.text().to_smolstr())));
-            Ok((Operand::Reference(token.text().to_smolstr()), ValueGuessType::Ref, opcode_table))
+            Ok((Operand::Reference(token.text().to_smolstr()), Ref, opcode_table))
         }
         ASTExprTree::This(_token) => {
             opcode_table.add_opcode(Push(None, Operand::This));
@@ -331,7 +350,7 @@ pub(crate) fn lower_expr(
             op: u_op,
             code: u_code,
         } => {
-            let mut a = lower_expr(semantic, u_code.as_ref(), code)?;
+            let mut a = lower_expr(semantic, u_code.as_ref(), code,None)?;
             let g_type = guess_type_unary(u_token, a.1, u_op)?;
             if let Some(operand) = unary_optimizer(u_op, &a.0) {
                 opcode_table.add_opcode(Push(None, operand));
@@ -347,24 +366,33 @@ pub(crate) fn lower_expr(
             left: e_left,
             right: e_right,
         } => {
-            let mut left = lower_expr(semantic, e_left.as_ref(), code)?;
-            let mut right = lower_expr(semantic, e_right.as_ref(), code)?;
-            let left_opd = Box::new(left.0.clone());
+            let mut right = lower_expr(semantic, e_right.as_ref(), code, None)?;
             let right_opd = Box::new(right.0.clone());
+            let stores = if matches!(e_op,ExprOp::Store) {
+                Some(right.0.clone())
+            }else {
+                None
+            };
+            let mut left = lower_expr(semantic, e_left.as_ref(), code, stores)?;
+
+            let left_opd = Box::new(left.0.clone());
             let guess_type = guess_type(e_token, left.1, right.1, e_op)?;
             let n_operand;
 
             if let Some(operand) = expr_optimizer(&left.0, &right.0, e_op) {
                 n_operand = operand.clone();
                 opcode_table.add_opcode(Push(None, operand));
             } else {
-                opcode_table.append_code(&mut left.2);
-                opcode_table.append_code(&mut right.2);
-
                 let opcode = astop_to_opcode(e_op);
-                n_operand = Operand::Expression(left_opd, right_opd, Box::from(opcode.clone()));
-
-                opcode_table.add_opcode(opcode);
+                if matches!(e_op,ExprOp::Store) {
+                    opcode_table.append_code(&mut right.2);
+                    opcode_table.append_code(&mut left.2);
+                }else {
+                    opcode_table.append_code(&mut left.2);
+                    opcode_table.append_code(&mut right.2);
+                    opcode_table.add_opcode(opcode.clone());
+                }
+                n_operand = Operand::Expression(left_opd, right_opd, Box::from(opcode));
             }
             Ok((n_operand, guess_type, opcode_table))
         }
@@ -380,22 +408,28 @@ pub(crate) fn lower_expr(
             if let Some(key) = code.find_value_key(var_name.clone()) {
                 let value = code.find_value(key).unwrap();
                 value.variable = true;
+                let type_ = value.type_.clone();
                 match value.type_ {
-                    ValueGuessType::Ref => {
+                    Ref => {
                         opcode_table.add_opcode(Push(None, Operand::Library(var_name)));
                     }
                     _ => {
-                        opcode_table.add_opcode(OpCode::StoreLocal(None, key, Operand::Val(key)));
+                        if let Some(operand) = store{
+                            value.type_ = operand_to_guess(operand);
+                            opcode_table.add_opcode(OpCode::LoadLocal(None, key, Operand::Val(key)));
+                        }else {
+                            opcode_table.add_opcode(OpCode::StoreLocal(None, key, Operand::Val(key)));
+                        }
                     }
                 };
-                Ok((Operand::Val(key), value.type_.clone(), opcode_table))
+                Ok((Operand::Val(key), type_, opcode_table))
             } else {
                 unreachable!()
             }
         }
         ASTExprTree::Call { name, args } => {
             for arg in args {
-                let mut expr = lower_expr(semantic, arg, code)?;
+                let mut expr = lower_expr(semantic, arg, code, None)?;
                 opcode_table.append_code(&mut expr.2);
             }
 
@@ -458,7 +492,7 @@ pub fn expr_semantic(
     let mut opcode_vec = OpCodeTable::new();
 
     if let Some(expr) = expr {
-        let mut exp = lower_expr(semantic, &expr, code)?;
+        let mut exp = lower_expr(semantic, &expr, code, None)?;
         opcode_vec.append_code(&mut exp.2);
         operand = exp.0;
         guess_type = exp.1;

src/compiler/semantic/optimizer.rs

@@ -41,6 +41,18 @@ pub fn expr_optimizer(left: &Operand, right: &Operand, op: &ExprOp) -> Option<Op
         (ImmNum(a), ImmNum(b), ExprOp::Div) => Some(ImmNum(a / b)),
         (ImmNum(a), ImmNum(b), ExprOp::Rmd) => Some(ImmNum(a % b)),
 
+        (ImmNum(a), ImmFlot(b), ExprOp::Add) => Some(ImmFlot(*a as f64 + b)),
+        (ImmNum(a), ImmFlot(b), ExprOp::Sub) => Some(ImmFlot(*a as f64 - b)),
+        (ImmNum(a), ImmFlot(b), ExprOp::Mul) => Some(ImmFlot(*a as f64 * b)),
+        (ImmNum(a), ImmFlot(b), ExprOp::Div) => Some(ImmFlot(*a as f64 / b)),
+        (ImmNum(a), ImmFlot(b), ExprOp::Rmd) => Some(ImmFlot(*a as f64 % b)),
+
+        (ImmFlot(a), ImmNum(b), ExprOp::Add) => Some(ImmFlot(a + *b as f64)),
+        (ImmFlot(a), ImmNum(b), ExprOp::Sub) => Some(ImmFlot(a - *b as f64)),
+        (ImmFlot(a), ImmNum(b), ExprOp::Mul) => Some(ImmFlot(a * *b as f64)),
+        (ImmFlot(a), ImmNum(b), ExprOp::Div) => Some(ImmFlot(a / *b as f64)),
+        (ImmFlot(a), ImmNum(b), ExprOp::Rmd) => Some(ImmFlot(a % *b as f64)),
+
         // 位运算
         (ImmNum(a), ImmNum(b), ExprOp::BitAnd) => Some(ImmNum(a & b)),
         (ImmNum(a), ImmNum(b), ExprOp::BitOr)  => Some(ImmNum(a | b)),

src/compiler/semantic/while.rs

@@ -14,7 +14,7 @@ pub fn while_semantic(
     code: &mut Code,
     locals:&mut LocalMap
 ) -> Result<OpCodeTable, ParserError> {
-    let mut exp = lower_expr(semantic, &expr, code)?;
+    let mut exp = lower_expr(semantic, &expr, code, None)?;
     let mut code_table = OpCodeTable::new();
 
     if exp.1 == ValueGuessType::Bool && !semantic.file.has_warnings(LoopNoExpr) {

src/lib.rs

@@ -0,0 +1,3 @@
+pub mod compiler;
+pub mod library;
+pub mod runtime;

src/library/mod.rs

@@ -50,7 +50,7 @@ fn register_library(library: LibModule) {
         .insert(library.name.clone(), library);
 }
 
-pub(crate) fn find_library(
+pub fn find_library(
     name: &str,
     f: impl FnOnce(Option<&mut LibModule>) -> Result<(), ParserError>,
 ) -> Result<(), ParserError> {