@ohos-graphics/stability-code-review 0.1.0

package/references/PerformanceStability/StabilityCodeReview_PerformanceStability_002.md

@@ -0,0 +1,437 @@
+---
+rule_id: "StabilityCodeReview_PerformanceStability_002"
+name: "间接递归风险"
+category: "性能稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 间接递归风险
+
+## 问题描述
+
+间接递归（A调用B，B调用A）可能导致无限循环或栈溢出。与直接递归不同，间接递归更隐蔽，容易被忽视。长时间运行或深度递归会耗尽栈空间，引发程序崩溃。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：简单间接递归 A->B->A
+void ProcessA(Data* data)
+{
+    if (data == nullptr) {
+        return;
+    }
+    
+    if (data->type == TYPE_A) {
+        ProcessB(data);  // A调用B
+    }
+}
+
+void ProcessB(Data* data)
+{
+    if (data == nullptr) {
+        return;
+    }
+    
+    if (data->flag) {
+        ProcessA(data);  // B调用A，形成A->B->A递归环
+    }
+}
+
+// 场景2：多函数递归环 A->B->C->A
+void HandleA(Request* req)
+{
+    if (req->step == 1) {
+        HandleB(req);  // A->B
+    }
+}
+
+void HandleB(Request* req)
+{
+    if (req->step == 2) {
+        HandleC(req);  // B->C
+    }
+}
+
+void HandleC(Request* req)
+{
+    if (req->retry) {
+        HandleA(req);  // C->A，形成A->B->C->A递归环
+    }
+}
+
+// 场景3：回调函数间接递归
+class EventHandler {
+public:
+    void OnEventA(Event* event) {
+        if (event->needRetry) {
+            ProcessEvent(event);  // OnEventA->ProcessEvent
+        }
+    }
+    
+    void ProcessEvent(Event* event) {
+        if (event->type == EVENT_A) {
+            OnEventA(event);  // ProcessEvent->OnEventA，递归环
+        }
+    }
+};
+
+// 场景4：条件分支递归
+void ValidateData(Data* data)
+{
+    if (!CheckConditionA(data)) {
+        CorrectData(data);  // ValidateData->CorrectData
+    }
+}
+
+void CorrectData(Data* data)
+{
+    if (!ValidateData(data)) {  // CorrectData->ValidateData，递归环
+        // 无限循环
+    }
+}
+
+// 场景5：虚函数间接递归
+class Base {
+public:
+    virtual void Process() {
+        Handle();
+    }
+    
+    virtual void Handle() {
+        Process();  // Handle->Process，递归环
+    }
+};
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：添加递归深度限制或状态标志
+void ProcessA(Data* data, int depth)
+{
+    if (data == nullptr || depth > MAX_DEPTH) {  // 正确：深度限制
+        return;
+    }
+    
+    if (data->type == TYPE_A) {
+        ProcessB(data, depth + 1);  // 传递深度参数
+    }
+}
+
+void ProcessB(Data* data, int depth)
+{
+    if (data == nullptr || depth > MAX_DEPTH) {  // 正确：深度限制
+        return;
+    }
+    
+    if (data->flag) {
+        ProcessA(data, depth + 1);  // 传递深度参数
+    }
+}
+
+// 修复场景2：使用循环代替递归
+void HandleRequest(Request* req)
+{
+    while (req != nullptr) {  // 正确：使用循环代替递归
+        switch (req->step) {
+            case 1:
+                // 处理步骤1
+                req->step = 2;
+                break;
+            case 2:
+                // 处理步骤2
+                req->step = 3;
+                break;
+            case 3:
+                // 处理步骤3
+                if (!req->retry) {
+                    return;  // 退出循环
+                }
+                req->step = 1;  // 重置步骤
+                break;
+        }
+    }
+}
+
+// 修复场景3：回调使用标志位防止递归
+class EventHandler {
+public:
+    void OnEventA(Event* event) {
+        if (event->processed) {  // 正确：检查标志位
+            return;
+        }
+        event->processed = true;
+        
+        if (event->needRetry) {
+            ProcessEvent(event);
+        }
+    }
+    
+    void ProcessEvent(Event* event) {
+        if (event->type == EVENT_A) {
+            OnEventA(event);  // 有标志位保护，不会递归
+        }
+    }
+};
+
+// 修复场景4：避免相互调用，使用状态机
+enum ValidationState {
+    STATE_CHECK,
+    STATE_CORRECT,
+    STATE_DONE
+};
+
+void ValidateDataStateMachine(Data* data)
+{
+    ValidationState state = STATE_CHECK;
+    
+    while (state != STATE_DONE) {  // 正确：状态机代替递归
+        switch (state) {
+            case STATE_CHECK:
+                if (CheckConditionA(data)) {
+                    state = STATE_DONE;
+                } else {
+                    state = STATE_CORRECT;
+                }
+                break;
+            case STATE_CORRECT:
+                CorrectData(data);
+                state = STATE_CHECK;  // 回到检查状态
+                break;
+        }
+    }
+}
+
+// 修复场景5：虚函数避免递归调用
+class Base {
+public:
+    virtual void Process() {
+        // 具体处理
+    }
+    
+    virtual void Handle() {
+        // 具体处理，不调用Process
+    }
+};
+
+// 修复场景6：Visitor模式中的间接递归防护
+class RSRenderServiceVisitor {
+public:
+    void PrepareNode(RSRenderNode& node) {
+        if (!canvas_) { return; }  // 终止条件1
+        if (!node.ShouldPaint()) { return; }  // 终止条件2
+        
+        PrepareChildren(node);  // 调用PrepareChildren
+    }
+    
+    void PrepareChildren(RSRenderNode& node) {
+        for (auto& child : *node.GetSortedChildren()) {
+            child->Prepare(shared_from_this());  // child->Prepare调用PrepareNode，形成间接递归
+        }
+    }
+};
+
+// Visitor模式正确实现：有迭代器终止条件和多重检查
+class SafeRenderVisitor {
+public:
+    void PrepareNode(RSRenderNode& node) {
+        if (node.IsVisited()) { return; }  // 终止条件：访问状态标志
+        if (!canvas_) { return; }  // 终止条件：canvas有效性
+        if (!node.ShouldPaint()) { return; }  // 终止条件：可见性
+        
+        node.SetVisited(true);  // 标记已访问
+        PrepareChildren(node);
+    }
+    
+    void PrepareChildren(RSRenderNode& node) {
+        auto children = node.GetSortedChildren();
+        if (!children || children->empty()) { return; }  // 终止条件：无子节点
+        
+        for (auto& child : *children) {  // 迭代器有终止条件
+            child->Prepare(shared_from_this());
+        }
+    }
+};
+
+// 修复场景7：使用跨节点访问状态标志
+class RSRenderNode {
+public:
+    void SetCrossNodeVisitedStatus(bool hasVisited);
+    void ResetCrossNodesVisitedStatus();  // 遍历前重置所有节点状态
+    
+    void Prepare(std::shared_ptr<Visitor> visitor) {
+        if (crossNodeVisited_) { return; }  // 防止重复处理
+        crossNodeVisited_ = true;
+        
+        // 处理节点
+        visitor->PrepareChildren(*this);
+    }
+private:
+    bool crossNodeVisited_ = false;  // 跨节点访问状态标志
+};
+```
+
+## 检测范围
+
+检查以下模式：
+
+- A函数调用B函数，B函数又调用A函数
+- 多函数递环（A->B->C->...->A）
+- 回调函数与处理函数相互调用
+- 虚函数之间相互调用
+- 条件分支中的相互调用
+
+## 检测要点
+
+1. 构建函数调用图，检测循环依赖
+2. 识别A->B->A模式的调用链
+3. 检查是否有递归深度限制参数
+4. 检查是否有状态标志防止递归
+5. 排除明确标记为安全的调用
+
+### Visitor模式的间接递归
+
+现代C++中Visitor模式常见的间接递归：Visitor -> child -> Visitor
+
+- **调用链**：
+  - Visitor::PrepareNode → Visitor::PrepareChildren
+  - PrepareChildren → child->Prepare(visitor)
+  - child->Prepare → Visitor::PrepareNode（回到Visitor）
+
+- **识别特征**：
+  - 使用迭代器遍历子节点：`for (auto& child : *node.GetChildren())`
+  - 子节点调用visitor：`child->Prepare(visitor)` 或 `child->Accept(visitor)`
+  - visitor函数名含Prepare/Accept/Visit
+
+- **防护机制**：
+  - 迭代器终止条件（遍历完所有子节点自然终止）
+  - 多重有效性检查（canvas有效性、节点可见性等）
+  - 跨节点访问状态标志（防止重复处理）
+
+### 迭代器遍历的深度控制
+
+Visitor模式依赖迭代器的物理限制：
+
+- 迭代器遍历子节点：`for (auto& child : *children)`
+- 终止条件：遍历完所有子节点后迭代器自然结束
+- 无传统递归：不使用函数直接调用自身
+
+**注意**：迭代器本身不限制深度，需要额外的终止条件。
+
+### 跨节点访问状态标志
+
+防止节点被重复处理的机制：
+
+- **状态标志**：`bool crossNodeVisited_`
+- **设置状态**：`SetCrossNodeVisitedStatus(true)`
+- **检查状态**：`if (crossNodeVisited_) return;`
+- **重置状态**：遍历前调用 `ResetCrossNodesVisitedStatus()`
+
+适用场景：
+- 跨节点的间接引用关系
+- 多个节点指向同一个子节点
+- 防止同一个节点被多次处理
+
+### 虚函数复杂间接递归
+
+虚函数多态可能形成复杂的间接递归：
+
+- Base::Prepare → Derived1::Handle → Base::Prepare
+- 需要构建虚函数调用图
+- 检查虚函数override中是否调用了父类虚函数
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：函数间相互调用形成递环
+- **RISK_TYPE**：无限递归
+- **RISK_PATH**：A->B->A循环调用 → 无限递归 → 栈溢出崩溃
+- **IMPACT_POINT**：栈空间耗尽，程序崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：满足递归条件且无终止机制
+- **Propagation**：无限函数调用，栈帧不断增长
+- **Consequence**：栈溢出崩溃、服务中断
+- **Mitigation**：添加递归深度限制、使用循环/状态机代替递归
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 有深度限制 | 参数传递depth且有MAX_DEPTH检查 | 不报 |
+| 有状态标志 | 有bool标志位检查防止递归 | 不报 |
+| 不同条件 | A->B和B->A的调用条件互斥 | 不报 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_PerformanceStability_002_trigger.cpp
+void trigger_bad_1(Data* data)
+{
+    if (data->type == TYPE_A) {
+        ProcessB(data);  // A->B
+    }
+}
+
+void trigger_bad_2(Data* data)
+{
+    if (data->flag) {
+        ProcessA(data);  // B->A，应该报：形成A->B->A递环
+    }
+}
+
+void trigger_bad_3(Request* req)
+{
+    HandleB(req);  // A->B
+}
+
+void trigger_bad_4(Request* req)
+{
+    HandleC(req);  // B->C
+}
+
+void trigger_bad_5(Request* req)
+{
+    HandleA(req);  // C->A，应该报：形成A->B->C->A递环
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_PerformanceStability_002_safe.cpp
+void safe_good_1(Data* data, int depth)
+{
+    if (depth > MAX_DEPTH) {  // 安全：有深度限制
+        return;
+    }
+    ProcessB(data, depth + 1);
+}
+
+void safe_good_2(Data* data, int depth)
+{
+    if (depth > MAX_DEPTH) {  // 安全：有深度限制
+        return;
+    }
+    ProcessA(data, depth + 1);
+}
+
+void safe_good_3(Request* req)
+{
+    while (req != nullptr) {  // 安全：使用循环
+        // 处理
+    }
+}
+
+// NOPROTECT: 特殊场景
+void noprotect_case(Data* data)
+{
+    ProcessB(data);  // NOPROTECT标记，不报
+}
+```

package/references/REPORT_TEMPLATE.csv

@@ -0,0 +1,5 @@
+问题序号,稳定性类别,规则名称,规则ID,问题描述,文件路径
+1,异常处理,异常未捕获风险,StabilityCodeReview_ExceptionHandling_001,【图形稳定性专项】【AI辅助代码检视】【异常处理】【异常未捕获风险】在<文件相对路径>:<行号>，函数<函数名>中，<问题描述>。,<文件相对路径>:<行号>
+2,并发稳定性,死锁风险,StabilityCodeReview_ConcurrencyStability_001,【图形稳定性专项】【AI辅助代码检视】【并发稳定性】【死锁风险】在<文件相对路径>:<起始行号>-<结束行号>，函数<函数名>中，<问题描述>。,<文件相对路径>:<起始行号>-<结束行号>
+3,内存稳定性,内存泄漏风险,StabilityCodeReview_MemoryStability_001,【图形稳定性专项】【AI辅助代码检视】【内存稳定性】【内存泄漏风险】在<文件相对路径>:<行号1>/<行号2>/<行号3>，函数<函数名>中，<问题描述>。,<文件相对路径>:<行号1>/<行号2>/<行号3>
+<N>,<稳定性类别>,<规则名称>,<规则ID>,【图形稳定性专项】【AI辅助代码检视】【<稳定性类别>】【<规则名称>】在<文件相对路径>:<行号>，函数<函数名>中，<问题描述>。,<文件相对路径>:<行号>

package/references/REPORT_TEMPLATE.md

@@ -0,0 +1,132 @@
+# OpenHarmony 稳定性代码审查报告
+
+**检视目标**: `<目录或文件相对路径>`  
+**检视时间**: `<YYYY-MM-DD HH:MM:SS>`  
+**检视框架版本**: OpenHarmony Stability Code Review Framework `<严格复制SKILL.md元数据中的metadata.version版本号字段>`  
+**检出问题总数**: `<总数>`  
+**严重程度分布**: CRITICAL(`<数量>`), HIGH(`<数量>`), MEDIUM(`<数量>`), LOW(`<数量>`)  
+**规则覆盖**: `<N>` 条规则（`<M>` 个稳定性分类）  
+
+---
+
+## 检视概览
+
+### 代码信息
+- **代码路径**: `<检视目标相对路径>`
+- **代码行数**: `<N>` 行
+- **功能描述**: `<功能描述文本>`
+
+### 问题统计
+
+| 严重程度 | 检出问题数 | 占比 | 说明 |
+|---------|---------|------|------|
+| CRITICAL | `<数量>` | `<百分比>%` | `<严重等级说明>` |
+| HIGH | `<数量>` | `<百分比>%` | `<严重等级说明>` |
+| MEDIUM | `<数量>` | `<百分比>%` | `<严重等级说明>` |
+| **总计** | **`<总数>`** | **100%** | **/** |
+
+### 分类问题分布
+
+| 分类名称 | 规则数量（已检视/总数） | 检出问题数 | 严重程度 |
+|---------|---------|-----------|---------|
+| 异常处理 | `<N>/<N>` | `<M>` | `<严重程度分布>` |
+| 并发稳定性 | `<N>/<N>` | `<M>` | `<严重程度分布>` |
+| 性能稳定性 | `<N>/<N>` | `<M>` | `<严重程度分布>` |
+| 资源管理 | `<N>/<N>` | `<M>` | `<严重程度分布>` |
+| 初始化顺序 | `<N>/<N>` | `<M>` | `<严重程度分布>` |
+| 边界条件 | `<N>/<N>` | `<M>` | `<严重程度分布>` |
+| 生命周期 | `<N>/<N>` | `<M>` | `<严重程度分布>` |
+| 内存稳定性 | `<N>/<N>` | `<M>` | `<严重程度分布>` |
+| 图形稳定性 | `<N>/<N>` | `<M>` | `<严重程度分布>` |
+| **总计** | **`<N>/<N>`** | **`<M>`** | **`<严重程度分布>`** |
+
+---
+
+## 检出问题详情
+
+### CRITICAL 级别问题（`<N>` 个）
+
+#### 问题 1: `<问题标题>`
+
+问题格式严格参考[检出问题格式模板](references/PROBLEM_TEMPLATE.md)
+
+---
+
+#### 问题 2: `<问题标题>`
+
+问题格式严格参考[检出问题格式模板](references/PROBLEM_TEMPLATE.md)
+
+---
+
+`<重复以上结构列出所有CRITICAL问题>`
+
+---
+
+### HIGH 级别问题（`<N>` 个）
+
+#### 问题 `<序号>`: `<问题标题>`
+
+问题格式严格参考[检出问题格式模板](references/PROBLEM_TEMPLATE.md)
+
+---
+
+#### 问题 `<序号>`: `<问题标题>`
+
+问题格式严格参考[检出问题格式模板](references/PROBLEM_TEMPLATE.md)
+
+---
+
+`<重复以上结构列出所有HIGH问题>`
+
+---
+
+### MEDIUM 级别问题（`<N>` 个）
+
+#### 问题 `<序号>`: `<问题标题>`
+
+问题格式严格参考[检出问题格式模板](references/PROBLEM_TEMPLATE.md)
+
+---
+
+#### 问题 `<序号>`: `<问题标题>`
+
+问题格式严格参考[检出问题格式模板](references/PROBLEM_TEMPLATE.md)
+
+---
+
+`<重复以上结构列出所有MEDIUM问题>`
+
+---
+
+## 修复优先级建议
+
+根据严重程度和影响范围，建议按以下优先级修复：
+
+### 第一优先级（CRITICAL，`<N>`个）
+1. **`<问题分类1>`**: `<问题描述>`（`<数量>`个）
+2. **`<问题分类2>`**: `<问题描述>`（`<数量>`个）
+3. **`<问题分类3>`**: `<问题描述>`（`<数量>`个）
+
+### 第二优先级（HIGH，`<N>`个）
+1. **`<问题分类1>`**: `<问题描述>`（`<数量>`个）
+2. **`<问题分类2>`**: `<问题描述>`（`<数量>`个）
+3. **`<问题分类3>`**: `<问题描述>`（`<数量>`个）
+
+### 第三优先级（MEDIUM，`<N>`个）
+1. **`<问题分类1>`**: `<问题描述>`（`<数量>`个）
+2. **`<问题分类2>`**: `<问题描述>`（`<数量>`个）
+3. **`<问题分类3>`**: `<问题描述>`（`<数量>`个）
+
+---
+
+## 附录
+
+### 白名单过滤
+- 文件路径: `<文件路径>`
+- `<白名单过滤规则说明>`
+- `<其他过滤条件>`
+
+---
+
+**报告生成时间**: `<YYYY-MM-DD HH:MM:SS>`  
+**报告生成者**: Agent