feat(warn): 添加与补充部分警告.

对标准库不规范写法纠正

Author: xiaoyi1212

lib/system.exf

@@ -7,7 +7,7 @@ function println(output) {
     print(output + "\n");
 }
 
-function readline() {
+function readline {
     var line = "";
     var c = "";
     var newline = "\n";

src/compiler/lints.rs

@@ -36,4 +36,5 @@ declare_lint! {
     UnusedValue "unused-value",
     UnusedLibrary "unused-library",
     UnusedExpression "unused-expression",
+    SyncRecursion "sync-recursion",
 }

src/compiler/parser/function.rs

@@ -1,9 +1,12 @@
+use crate::compiler::Compiler;
 use crate::compiler::ast::{ASTExprTree, ASTStmtTree};
 use crate::compiler::lexer::TokenType;
 use crate::compiler::lexer::TokenType::{LP, LR};
+use crate::compiler::lints::Lint::FuncNoArg;
 use crate::compiler::parser::ParserError::{Expected, IdentifierExpected, IllegalArgument};
 use crate::compiler::parser::block::blk_eval;
 use crate::compiler::parser::{Parser, ParserError, check_char};
+use smol_str::format_smolstr;
 
 fn parser_argument(parser: &mut Parser) -> Result<Vec<ASTExprTree>, ParserError> {
     let mut token = parser.next_parser_token()?;
@@ -82,8 +85,22 @@ pub fn func_eval(parser: &mut Parser) -> Result<ASTStmtTree, ParserError> {
                 parser.cache = Some(token);
                 args = vec![];
             } else {
+                let pt = token.clone();
                 parser.cache = Some(token);
                 args = parser_argument(parser)?;
+                if args.is_empty() && !is_native {
+                    Compiler::warning_info_expr(
+                        parser.file,
+                        format_smolstr!(
+                            "'function {}()' can be written as 'function {}'",
+                            name.text(),
+                            name.text()
+                        )
+                        .as_str(),
+                        &ASTExprTree::Literal(pt),
+                        FuncNoArg,
+                    );
+                }
             }
         }
         TokenType::End => {
@@ -108,6 +125,11 @@ pub fn func_eval(parser: &mut Parser) -> Result<ASTStmtTree, ParserError> {
     } else {
         parser.cache = Some(token);
         let body = blk_eval(parser)?;
-        Ok(ASTStmtTree::Function { name, sync: is_sync, args, body })
+        Ok(ASTStmtTree::Function {
+            name,
+            sync: is_sync,
+            args,
+            body,
+        })
     }
 }

src/compiler/parser/symbol_table.rs

@@ -29,6 +29,8 @@ pub struct Element {
 pub struct Context {
     elements: Vec<Element>,
     ctxt_type: ContextType,
+    pub func_sync: bool, // 仅当上下文类型为 func 时有意义
+    pub func_name: SmolStr, // 同上
 }
 
 #[derive(Debug, Clone)]
@@ -42,6 +44,8 @@ impl SymbolTable {
         table.contexts.push(Context {
             elements: vec![],
             ctxt_type: ContextType::Root,
+            func_sync: false,
+            func_name: SmolStr::new(""),
         });
         table
     }
@@ -73,6 +77,8 @@ impl SymbolTable {
         self.contexts.push(Context {
             elements: vec![],
             ctxt_type,
+            func_name: SmolStr::new(""),
+            func_sync: false,
         });
     }
 

src/compiler/semantic/expression.rs

@@ -1,3 +1,4 @@
+use crate::compiler::Compiler;
 use crate::compiler::ast::ssa_ir::OpCode::Push;
 use crate::compiler::ast::ssa_ir::Operand::ImmNumFlot;
 use crate::compiler::ast::ssa_ir::ValueGuessType::{
@@ -6,8 +7,9 @@ use crate::compiler::ast::ssa_ir::ValueGuessType::{
 use crate::compiler::ast::ssa_ir::{OpCode, OpCodeTable, Operand, ValueAlloc, ValueGuessType};
 use crate::compiler::ast::{ASTExprTree, ExprOp};
 use crate::compiler::lexer::{Token, TokenType};
+use crate::compiler::lints::Lint::SyncRecursion;
 use crate::compiler::parser::ParserError;
-use crate::compiler::parser::symbol_table::ElementType;
+use crate::compiler::parser::symbol_table::{ContextType, ElementType};
 use crate::compiler::semantic::Semantic;
 use crate::compiler::semantic::optimizer::{expr_optimizer, unary_optimizer};
 use slotmap::DefaultKey;
@@ -352,7 +354,23 @@ fn lower_ref(
         };
 
         if let Some(base) = base {
-            let full_path = format_smolstr!("{}/{}", base, token.text());
+            let full_path = format_smolstr!("{base}/{}", token.text());
+
+            if file_base == base && let Some(context) = semantic
+                .compiler_data()
+                .symbol_table
+                .get_context(&ContextType::Func)
+                && context.func_sync
+                && context.func_name.as_str() == token.text()
+            {
+                Compiler::warning_info_expr(
+                    semantic.file,
+                    "unsafe recursion in synchronized function.",
+                    right_tree,
+                    SyncRecursion,
+                );
+            }
+
             opcode_table.add_opcode(Push(None, Operand::Reference(full_path)));
             return Ok((token.text().to_smolstr(), opcode_table));
         }
@@ -578,6 +596,23 @@ fn expr_call(
                 .next()
                 .unwrap_or(semantic.file.name.as_str());
             let full_path = format_smolstr!("{file_base}/{path}");
+
+            // 检查同步函数递归调用
+            if let Some(context) = semantic
+                .compiler_data()
+                .symbol_table
+                .get_context(&ContextType::Func)
+                && context.func_name == path
+                && context.func_sync
+            {
+                Compiler::warning_info_expr(
+                    semantic.file,
+                    "unsafe recursion in synchronized function.",
+                    name,
+                    SyncRecursion,
+                );
+            }
+
             opcode_table.add_opcode(Push(None, Operand::Reference(full_path)));
             opcode_table.add_opcode(OpCode::Call(None, path.clone()));
             Ok((Operand::Call(path), Unknown, opcode_table))

src/compiler/semantic/function.rs

@@ -69,6 +69,14 @@ pub fn function_semantic(
         .compiler_data()
         .symbol_table
         .add_context(ContextType::Func);
+    let context = semantic
+        .compiler_data()
+        .symbol_table
+        .get_context(&ContextType::Func)
+        .unwrap();
+    context.func_sync = sync;
+    context.func_name = name.text().to_smolstr();
+
     let mut tables = OpCodeTable::new();
     let mut locals = LocalMap::new();
     let mut value_alloc = ValueAlloc::new();