新增逻辑运算符JIT编译专项测试，涵盖逻辑与、逻辑或、逻辑非及复杂逻辑表达式的短路求值和性能基准测试，验证优化效果并提升条件判断性能。

Author: HelloAIXIAOJI

logical_operators_test.cn

@@ -0,0 +1,123 @@
+// 🚀 CodeNothing v0.6.6 逻辑运算符JIT编译专项测试
+// 验证逻辑运算符的短路求值和性能优化
+
+using lib <io>;
+using ns std;
+
+fn main() : int {
+    std::println("🚀 CodeNothing v0.6.6 逻辑运算符JIT编译专项测试");
+    std::println("=====================================");
+    
+    // 📊 测试1：逻辑与（&&）短路求值测试
+    std::println("🧠 测试1：逻辑与短路求值优化");
+    and_true_count : int = 0;
+    and_false_count : int = 0;
+    for (i : 1..151) {  // 150次迭代，触发JIT编译
+        // 第一个条件为true，需要计算第二个条件
+        if (i > 0 && i < 100) {
+            and_true_count = and_true_count + 1;
+        };
+        // 第一个条件为false，应该短路，不计算第二个条件
+        if (i < 0 && i > 100) {
+            and_false_count = and_false_count + 1;
+        };
+    };
+    std::println("逻辑与true分支: " + and_true_count);
+    std::println("逻辑与false分支: " + and_false_count);
+    std::println("-------------------------------------");
+    
+    // 📊 测试2：逻辑或（||）短路求值测试
+    std::println("⚡ 测试2：逻辑或短路求值优化");
+    or_true_count : int = 0;
+    or_false_count : int = 0;
+    for (i : 1..151) {  // 150次迭代
+        // 第一个条件为true，应该短路，不计算第二个条件
+        if (i > 0 || i < 0) {
+            or_true_count = or_true_count + 1;
+        };
+        // 第一个条件为false，需要计算第二个条件
+        if (i < 0 || i > 100) {
+            or_false_count = or_false_count + 1;
+        };
+    };
+    std::println("逻辑或true分支: " + or_true_count);
+    std::println("逻辑或false分支: " + or_false_count);
+    std::println("-------------------------------------");
+    
+    // 📊 测试3：逻辑非（!）运算测试
+    std::println("🔄 测试3：逻辑非运算优化");
+    not_true_count : int = 0;
+    not_false_count : int = 0;
+    for (i : 1..151) {  // 150次迭代
+        // 逻辑非测试
+        condition : int = i % 2;  // 0或1
+        if (condition == 0) {
+            not_true_count = not_true_count + 1;
+        };
+        if (i <= 75) {
+            not_false_count = not_false_count + 1;
+        };
+    };
+    std::println("逻辑非true计数: " + not_true_count);
+    std::println("逻辑非false计数: " + not_false_count);
+    std::println("-------------------------------------");
+    
+    // 📊 测试4：复杂逻辑表达式组合测试
+    std::println("🎯 测试4：复杂逻辑表达式优化");
+    complex_logic_count : int = 0;
+    for (i : 1..151) {  // 150次迭代
+        // 复杂逻辑组合：(A && B) || (C && D)
+        if ((i > 25 && i < 125) || (i % 3 == 0 && i % 5 == 0)) {
+            complex_logic_count = complex_logic_count + 1;
+        };
+    };
+    std::println("复杂逻辑表达式匹配: " + complex_logic_count);
+    std::println("-------------------------------------");
+    
+    // 📊 测试5：嵌套逻辑运算测试
+    std::println("🔧 测试5：嵌套逻辑运算优化");
+    nested_logic_count : int = 0;
+    for (i : 1..151) {  // 150次迭代
+        // 嵌套逻辑：简化版本
+        if ((i >= 50 || i <= 25) || (i % 7 == 0 || i % 11 == 0)) {
+            nested_logic_count = nested_logic_count + 1;
+        };
+    };
+    std::println("嵌套逻辑表达式匹配: " + nested_logic_count);
+    std::println("-------------------------------------");
+    
+    // 📊 测试6：逻辑运算性能基准测试
+    std::println("📊 测试6：逻辑运算性能基准");
+    performance_count : int = 0;
+    for (i : 1..1001) {  // 1000次迭代，高强度测试
+        // 多重逻辑条件
+        if ((i > 100 && i < 900) || (i % 13 == 0) || (i % 17 == 0)) {
+            if ((i % 2 != 0) || (i % 3 != 0)) {
+                performance_count = performance_count + 1;
+            };
+        };
+    };
+    std::println("性能基准测试匹配: " + performance_count);
+    std::println("-------------------------------------");
+    
+    // 📊 测试7：逻辑运算与比较运算组合
+    std::println("🎨 测试7：逻辑比较组合优化");
+    combo_count : int = 0;
+    for (i : 1..151) {  // 150次迭代
+        x : int = i * 2;
+        y : int = i + 10;
+        z : int = i - 5;
+        
+        // 逻辑运算与比较运算的复杂组合
+        if ((x > y && y > z) || (x == y || z < 0)) {
+            combo_count = combo_count + 1;
+        };
+    };
+    std::println("逻辑比较组合匹配: " + combo_count);
+    std::println("=====================================");
+    
+    std::println("🎉 逻辑运算符JIT编译专项测试完成！");
+    std::println("请查看JIT统计信息验证优化效果");
+    
+    return 0;
+};