一些言语更改

Author: HelloAIXIAOJI

src/analyzer/type_checker.rs

@@ -32,7 +32,7 @@ impl TypeCheckError {
 pub struct TypeChecker {
     // 变量类型表
     variable_types: HashMap<String, Type>,
-    // 🚀 v0.6.2 新增：常量类型表
+    //  v0.6.2 新增：常量类型表
     constant_types: HashMap<String, Type>,
     // 函数签名表
     function_signatures: HashMap<String, (Vec<Type>, Type)>, // (参数类型, 返回类型)
@@ -42,7 +42,7 @@ pub struct TypeChecker {
     class_methods: HashMap<String, HashMap<String, (Vec<Type>, Type)>>, // 类名 -> 方法名 -> (参数类型, 返回类型)
     // 枚举定义表
     enum_definitions: HashMap<String, Vec<String>>, // 枚举名 -> 变体列表
-    // 🚀 v0.8.4 新增：泛型支持
+    //  v0.8.4 新增：泛型支持
     // 泛型函数签名表
     generic_function_signatures: HashMap<String, (Vec<GenericParameter>, Vec<Type>, Type)>, // 函数名 -> (泛型参数, 参数类型, 返回类型)
     // 泛型类定义表
@@ -64,7 +64,7 @@ impl TypeChecker {
             class_definitions: HashMap::new(),
             class_methods: HashMap::new(),
             enum_definitions: HashMap::new(),
-            // 🚀 v0.8.4 新增：泛型支持
+            //  v0.8.4 新增：泛型支持
             generic_function_signatures: HashMap::new(),
             generic_class_definitions: HashMap::new(),
             current_generic_context: HashMap::new(),
@@ -78,7 +78,7 @@ impl TypeChecker {
         // 第一遍：收集所有函数、类、枚举的定义
         self.collect_program_definitions(program);
 
-        // 🔧 修复：收集命名空间中的函数定义
+        //  修复：收集命名空间中的函数定义
         for namespace in &program.namespaces {
             for function in &namespace.functions {
                 let param_types: Vec<Type> = function.parameters.iter()
@@ -121,7 +121,7 @@ impl TypeChecker {
 
     // 收集程序定义阶段
     fn collect_program_definitions(&mut self, program: &Program) {
-        // 🚀 v0.6.2 收集常量定义
+        //  v0.6.2 收集常量定义
         for (name, const_type, _expr) in &program.constants {
             self.constant_types.insert(name.clone(), const_type.clone());
         }
@@ -137,8 +137,8 @@ impl TypeChecker {
             );
         }
 
-        // 🔧 修复：收集导入的命名空间中的库函数
-        // 🔧 移除硬编码的函数签名，应该从动态库系统获取
+        //  修复：收集导入的命名空间中的库函数
+        //  移除硬编码的函数签名，应该从动态库系统获取
         // TODO: 实现从已加载库中动态获取函数签名的机制
         for (ns_type, path) in &program.imported_namespaces {
             match ns_type {
@@ -428,7 +428,7 @@ impl TypeChecker {
             Expression::LongLiteral(_) => Type::Long,
 
             Expression::Variable(name) => {
-                // 🚀 v0.6.2 先检查常量，再检查变量
+                //  v0.6.2 先检查常量，再检查变量
                 if let Some(const_type) = self.constant_types.get(name) {
                     const_type.clone()
                 } else if let Some(var_type) = self.variable_types.get(name) {
@@ -729,7 +729,7 @@ impl TypeChecker {
 
     // 检查函数调用
     fn check_function_call(&mut self, name: &str, args: &[Expression]) -> Type {
-        // 🔧 首先检查是否是内置函数
+        //  首先检查是否是内置函数
         match name {
             "println" | "print" => {
                 // 内置输出函数，接受任意数量的参数
@@ -764,7 +764,7 @@ impl TypeChecker {
 
             return_type
         } else {
-            // 🚀 v0.6.2 修复：可能是导入的命名空间函数，假设为有效
+            //  v0.6.2 修复：可能是导入的命名空间函数，假设为有效
             // 在运行时会进行实际的函数查找和调用
             Type::Auto // 假设函数存在，返回Auto类型
         }
@@ -950,7 +950,7 @@ impl TypeChecker {
                 self.types_compatible(expected_element, actual_element)
             },
 
-            // 🚀 v0.8.4 新增：泛型类型兼容性
+            //  v0.8.4 新增：泛型类型兼容性
             (Type::Generic(name1), Type::Generic(name2)) => name1 == name2,
             (Type::Generic(name), actual_type) => {
                 // 检查泛型参数是否已绑定到具体类型
@@ -981,7 +981,7 @@ impl TypeChecker {
         }
     }
 
-    // 🚀 v0.8.4 新增：泛型类型检查方法
+    //  v0.8.4 新增：泛型类型检查方法
 
     /// 检查泛型约束是否满足
     pub fn check_generic_constraints(&self, type_param: &str, actual_type: &Type, constraints: &[TypeConstraint]) -> bool {

src/interpreter/expression_evaluator.rs

@@ -115,13 +115,13 @@ impl<'a> Interpreter<'a> {
             // 尝试编译数学表达式
             match jit.compile_math_expression(expr, key.clone(), true) {
                 Ok(_compiled) => {
-                    crate::jit_debug_println!("✅ 数学表达式JIT编译成功: {}", key);
+                    crate::jit_debug_println!(" 数学表达式JIT编译成功: {}", key);
                     // 编译成功，记录在统计中
                     // 注意：这里我们暂时返回None，因为实际执行需要更复杂的实现
                     // 但是编译过程已经被记录在统计中
                 },
                 Err(e) => {
-                    println!("❌ 数学表达式JIT编译失败: {} - {}", key, e);
+                    println!(" 数学表达式JIT编译失败: {} - {}", key, e);
                     // 编译失败，继续使用解释执行
                 }
             }
@@ -207,7 +207,7 @@ impl<'a> ExpressionEvaluator for Interpreter<'a> {
     fn evaluate_expression(&mut self, expr: &Expression) -> Value {
         // 检查超时和操作次数限制
         if let Err(timeout_msg) = self.check_timeout() {
-            eprintln!("⚠️ 执行超时: {}", timeout_msg);
+            eprintln!("️ 执行超时: {}", timeout_msg);
             return Value::None;
         }
 
@@ -273,11 +273,11 @@ impl<'a> ExpressionEvaluator for Interpreter<'a> {
                 Value::Array(values)
             },
             Expression::ArrayAccess(array_expr, index_expr) => {
-                // 🧮 数组访问JIT编译检查
+                //  数组访问JIT编译检查
                 let array_key = format!("array_access_{:p}", expr as *const _);
                 if jit::should_compile_array_operation(&array_key) {
                     if let Ok(_compiled) = jit::compile_array_operation(expr, array_key.clone(), false) {
-                        println!("✅ 数组访问JIT编译成功: {}", array_key);
+                        println!(" 数组访问JIT编译成功: {}", array_key);
                     }
                 }
 
@@ -498,15 +498,15 @@ impl<'a> ExpressionEvaluator for Interpreter<'a> {
                 }
             },
             Expression::StaticMethodCall(class_name, method_name, args) => {
-                // 🔧 首先检查是否是库命名空间函数调用
+                //  首先检查是否是库命名空间函数调用
                 if self.library_namespaces.contains_key(class_name) {
                     debug_println(&format!("StaticMethodCall被识别为库命名空间函数调用: {}::{}", class_name, method_name));
                     // 转换为命名空间函数调用
                     let path = vec![class_name.clone(), method_name.clone()];
                     return self.handle_namespaced_function_call(&path, args);
                 }
 
-                // 🔧 新增：检查是否是代码命名空间函数调用
+                //  新增：检查是否是代码命名空间函数调用
                 let potential_ns_path = format!("{}::{}", class_name, method_name);
                 if self.namespaced_functions.contains_key(&potential_ns_path) {
                     debug_println(&format!("StaticMethodCall被识别为代码命名空间函数调用: {}", potential_ns_path));
@@ -599,11 +599,11 @@ impl<'a> ExpressionEvaluator for Interpreter<'a> {
                 self.apply_function(func_value, arg_values)
             },
             Expression::ArrayMap(array_expr, lambda_expr) => {
-                // 🧮 数组map操作JIT编译检查
+                //  数组map操作JIT编译检查
                 let map_key = format!("array_map_{:p}", expr as *const _);
                 if jit::should_compile_array_operation(&map_key) {
                     if let Ok(_compiled) = jit::compile_array_operation(expr, map_key.clone(), false) {
-                        println!("✅ 数组map操作JIT编译成功: {}", map_key);
+                        println!(" 数组map操作JIT编译成功: {}", map_key);
                     }
                 }
 
@@ -613,11 +613,11 @@ impl<'a> ExpressionEvaluator for Interpreter<'a> {
                 self.array_map(array_value, lambda_value)
             },
             Expression::ArrayFilter(array_expr, lambda_expr) => {
-                // 🧮 数组filter操作JIT编译检查
+                //  数组filter操作JIT编译检查
                 let filter_key = format!("array_filter_{:p}", expr as *const _);
                 if jit::should_compile_array_operation(&filter_key) {
                     if let Ok(_compiled) = jit::compile_array_operation(expr, filter_key.clone(), false) {
-                        println!("✅ 数组filter操作JIT编译成功: {}", filter_key);
+                        println!(" 数组filter操作JIT编译成功: {}", filter_key);
                     }
                 }
 
@@ -627,11 +627,11 @@ impl<'a> ExpressionEvaluator for Interpreter<'a> {
                 self.array_filter(array_value, lambda_value)
             },
             Expression::ArrayReduce(array_expr, lambda_expr, initial_expr) => {
-                // 🧮 数组reduce操作JIT编译检查
+                //  数组reduce操作JIT编译检查
                 let reduce_key = format!("array_reduce_{:p}", expr as *const _);
                 if jit::should_compile_array_operation(&reduce_key) {
                     if let Ok(_compiled) = jit::compile_array_operation(expr, reduce_key.clone(), false) {
-                        println!("✅ 数组reduce操作JIT编译成功: {}", reduce_key);
+                        println!(" 数组reduce操作JIT编译成功: {}", reduce_key);
                     }
                 }
 
@@ -642,11 +642,11 @@ impl<'a> ExpressionEvaluator for Interpreter<'a> {
                 self.array_reduce(array_value, lambda_value, initial_value)
             },
             Expression::ArrayForEach(array_expr, lambda_expr) => {
-                // 🧮 数组forEach操作JIT编译检查
+                //  数组forEach操作JIT编译检查
                 let foreach_key = format!("array_foreach_{:p}", expr as *const _);
                 if jit::should_compile_array_operation(&foreach_key) {
                     if let Ok(_compiled) = jit::compile_array_operation(expr, foreach_key.clone(), false) {
-                        println!("✅ 数组forEach操作JIT编译成功: {}", foreach_key);
+                        println!(" 数组forEach操作JIT编译成功: {}", foreach_key);
                     }
                 }
 
@@ -761,7 +761,7 @@ impl<'a> ExpressionEvaluator for Interpreter<'a> {
                 self.evaluate_match_expression(*match_expr.clone(), arms.clone())
             },
 
-            // 🚀 v0.8.4 改进：泛型相关表达式
+            //  v0.8.4 改进：泛型相关表达式
             Expression::GenericFunctionCall(func_name, type_args, args) => {
                 // 改进的泛型函数调用处理
                 self.handle_generic_function_call(func_name, type_args, args).unwrap_or(Value::None)
@@ -1060,11 +1060,11 @@ impl<'a> Interpreter<'a> {
                 self.handle_string_method(&s, method_name, &evaluated_args)
             },
             Value::Array(arr) => {
-                // 🧮 数组方法调用JIT编译检查
+                //  数组方法调用JIT编译检查
                 let method_key = format!("array_method_{}_{:p}", method_name, obj_expr as *const _);
                 if jit::should_compile_array_operation(&method_key) {
                     if let Ok(_compiled) = jit::compile_array_operation(obj_expr, method_key.clone(), false) {
-                        println!("✅ 数组方法{}JIT编译成功: {}", method_name, method_key);
+                        println!(" 数组方法{}JIT编译成功: {}", method_name, method_key);
                     }
                 }
 
@@ -1875,7 +1875,7 @@ impl<'a> Interpreter<'a> {
                     arg_values.push(self.evaluate_expression(arg));
                 }
 
-                // 🧠 记忆化缓存检查（仅对记忆化方法）
+                //  记忆化缓存检查（仅对记忆化方法）
                 if method_clone.is_memoized {
                     let method_full_name = format!("{}::{}", obj.class_name, method_name);
 
@@ -1884,7 +1884,7 @@ impl<'a> Interpreter<'a> {
                     cache_args.extend(arg_values.clone());
 
                     if let Some(cached_result) = super::memoization::memo_get(&method_full_name, &cache_args) {
-                        debug_println(&format!("🧠 方法记忆化缓存命中: {}({:?}) -> {:?}", method_full_name, cache_args, cached_result));
+                        debug_println(&format!(" 方法记忆化缓存命中: {}({:?}) -> {:?}", method_full_name, cache_args, cached_result));
                         return cached_result;
                     }
                 }
@@ -1900,7 +1900,7 @@ impl<'a> Interpreter<'a> {
                 // 执行方法体，传递this对象和参数环境
                 let (result, updated_obj) = self.execute_method_body_with_context(&method_clone.body, &obj, &method_env);
 
-                // 🧠 记忆化缓存存储（仅对记忆化方法）
+                //  记忆化缓存存储（仅对记忆化方法）
                 if method_clone.is_memoized {
                     let method_full_name = format!("{}::{}", obj.class_name, method_name);
 
@@ -1909,7 +1909,7 @@ impl<'a> Interpreter<'a> {
                     cache_args.extend(arg_values.clone());
 
                     super::memoization::memo_put(&method_full_name, &cache_args, result.clone());
-                    debug_println(&format!("🧠 方法记忆化缓存存储: {}({:?}) -> {:?}", method_full_name, cache_args, result));
+                    debug_println(&format!(" 方法记忆化缓存存储: {}({:?}) -> {:?}", method_full_name, cache_args, result));
                 }
 
                 // 更新原始对象的状态
@@ -2299,7 +2299,7 @@ impl<'a> Interpreter<'a> {
                         return Value::None;
                     }
 
-                    // 🧠 记忆化缓存检查（仅对记忆化方法）
+                    //  记忆化缓存检查（仅对记忆化方法）
                     if method_clone.is_memoized {
                         let method_full_name = format!("{}::{}", this_obj.class_name, method_name);
 
@@ -2308,7 +2308,7 @@ impl<'a> Interpreter<'a> {
                         cache_args.extend(arg_values.clone());
 
                         if let Some(cached_result) = super::memoization::memo_get(&method_full_name, &cache_args) {
-                            debug_println(&format!("🧠 this方法记忆化缓存命中: {}({:?}) -> {:?}", method_full_name, cache_args, cached_result));
+                            debug_println(&format!(" this方法记忆化缓存命中: {}({:?}) -> {:?}", method_full_name, cache_args, cached_result));
                             return cached_result;
                         }
                     }
@@ -2324,7 +2324,7 @@ impl<'a> Interpreter<'a> {
                     // 执行方法体，传递this对象和参数环境
                     let (result, _updated_obj) = self.execute_method_body_with_context(&method_clone.body, this_obj, &method_env_new);
 
-                    // 🧠 记忆化缓存存储（仅对记忆化方法）
+                    //  记忆化缓存存储（仅对记忆化方法）
                     if method_clone.is_memoized {
                         let method_full_name = format!("{}::{}", this_obj.class_name, method_name);
 
@@ -2333,7 +2333,7 @@ impl<'a> Interpreter<'a> {
                         cache_args.extend(arg_values.clone());
 
                         super::memoization::memo_put(&method_full_name, &cache_args, result.clone());
-                        debug_println(&format!("🧠 this方法记忆化缓存存储: {}({:?}) -> {:?}", method_full_name, cache_args, result));
+                        debug_println(&format!(" this方法记忆化缓存存储: {}({:?}) -> {:?}", method_full_name, cache_args, result));
                     }
 
                     return result;
@@ -4210,7 +4210,7 @@ impl<'a> Interpreter<'a> {
     }
 
 
-    // 🚀 v0.8.4 新增：改进的泛型表达式处理方法
+    //  v0.8.4 新增：改进的泛型表达式处理方法
 
     /// 处理泛型函数调用
     fn handle_generic_function_call(&mut self, func_name: &str, type_args: &[Type], args: &[Expression]) -> Result<Value, String> {