---
name: f2r-check
description: |
  Fortran 到 Rust 模块一致性检查与修复。触发条件：
  - 用户提到 "检查模块"、"对比模块"、"f2r_check"、"f2r check"、"下一个模块"
  - 用户询问 Rust 模块是否与 Fortran 源码匹配
  - 用户想验证或修复 Rust 实现的正确性

  核心工作流：获取推荐 → 检查差异 → **直接修复** → 验证编译 → **继续下一个**
  **自动化模式**：检查发现差异后必须立即修复，禁止询问用户，禁止生成总结报告。
---

# F2R Check - Fortran 到 Rust 自动化修复（两阶段检查）

**这是一个自动化任务**。检查发现差异后必须立即修复，修复完成后自动继续下一个模块。

## 关键规则（必须遵守）

```
┌─────────────────────────────────────────────────────────────────┐
│  禁止事项：                                                       │
│  ❌ 禁止生成总结报告后询问"是否继续"                              │
│  ❌ 禁止说"这个模块很复杂，是否要修复"                             │
│  ❌ 禁止只检查不修复                                              │
│  ❌ 禁止输出冗长的检查报告                                        │
│  ❌ 禁止因为模块复杂就跳过                                        │
│  ❌ 禁止自行判断"这个差异不重要"然后跳过                          │
│  ❌ 禁止跳过 I/O 语句（write/read/print）                         │
│                                                                   │
│  必须事项：                                                       │
│  ✅ 只有脚本返回 "✅ match" 且无 HIGH_RISK 才能跳过              │
│  ✅ 任何 non-match 状态都必须修复                                 │
│  ✅ ✅ match + HIGH_RISK 必须进行 Phase 2 深度检查               │
│  ✅ I/O 语句必须实现（用 log::debug! 或条件打印）                 │
│  ✅ 检查发现差异 → 立即修复                                       │
│  ✅ 修复完成 → 立即验证编译                                       │
│  ✅ 编译通过 → 立即继续下一个模块                                 │
│  ✅ 只输出：修复了什么 + 编译结果                                 │
│  ✅ 遇到复杂模块也要修复，分解为小步骤逐步完成                     │
└─────────────────────────────────────────────────────────────────┘
```

## 两阶段检查流程

### Phase 1: Python 快速风险检测（自动）

```
步骤 1: 获取推荐模块
$ python3 .claude/skills/f2r-check/scripts/next_module.py
        │
        ▼
步骤 2: 快速检查差异
$ python3 .claude/skills/f2r-check/scripts/f2r_check.py --diff <MODULE>
        │
        ├── ❌ mismatch/partial → 立即修复（现有流程）→ 步骤 4
        │
        └── ✅ match → 步骤 3: 风险评估
                │
                ▼
步骤 3: $ python3 .claude/skills/f2r-check/scripts/f2r_check.py --risk <MODULE>
        │
        ├── 有 HIGH_RISK → 进入 Phase 2
        │
        └── 无风险 → 输出 "模块已完整，跳过" → 继续步骤 1
```

### Phase 2: Claude 深度语义对比（手动触发或自动）

Phase 1 发现 HIGH_RISK 后，Claude 逐行对比 Fortran 和 Rust：

```
Phase 2 步骤:
1. 读取 Fortran 源码
2. 读取 Rust 源码
3. 读取 INCLUDE 的 COMMON 定义文件
4. 读取 use 引用的 Rust struct 文件
5. 逐块对比（变量映射、索引转换、数组维度、赋值完整性）
6. 发现 bug → 立即修复 → cargo build 验证
7. 无 bug → 输出 "深度检查通过" → 继续下一个
```

### Phase 2 检查清单

对每个 HIGH_RISK 模块，必须逐项检查：

```
[ ] COMMON 变量 → 正确的 Rust struct 字段
    使用: python3 scripts/common_db.py --module <MODULE>

[ ] 2D 数组下标顺序（Fortran 列主序 → Rust 行主序）
    Fortran XDO(3,MHOD) 第一个下标变化最快
    Rust xdo[[mhod_idx][3_idx] 需要交换下标

[ ] 1-based → 0-based 索引一致性
    IJ00=1 → ij00=0
    DO I=1,N → for i in 0..n

[ ] 循环边界转换
    DO I=1,N → for i in 0..n (不是 0..n-1)
    DO I=N,1,-1 → for i in (0..n).rev()

[ ] IF 条件完整保留
    <= vs <, >= vs >, .EQ. vs ==
    .AND. vs &&, .OR. vs ||

[ ] 所有赋值目标存在（无遗漏的 LINEXP 等）
    检查每个 Fortran 赋值语句是否有对应 Rust 赋值

[ ] CALL 顺序和数量一致
    每个 CALL 都有对应 Rust 函数调用
    调用顺序与 Fortran 一致

[ ] 类型转换正确
    INTEGER → i32, REAL*8 → f64, LOGICAL → bool
    REAL*4 → f32, INTEGER*2 → i16
```

## 判断标准

| 脚本输出 | 风险等级 | 行动 | 允许跳过？ |
|----------|----------|------|------------|
| `✅ match` + 无风险 | 无 | 跳过 | ✅ 是 |
| `✅ match` + HIGH_RISK | 高 | Phase 2 深度检查 | ❌ 否 |
| `✅ match` + MEDIUM_RISK | 中 | Phase 2 深度检查 | ❌ 否 |
| `⚠️ partial` | — | 立即修复 | ❌ 否 |
| `❌ mismatch` | — | 立即修复 | ❌ 否 |
| `❓ missing` | — | 立即实现 | ❌ 否 |

## 输出格式（严格遵守）

**只输出以下简洁格式：**

```
检查: <模块名> - <状态>
风险: <N HIGH, M MEDIUM> (如有)
修复: <修复内容简述>
编译: <成功/失败>
```

**禁止输出：**
- 长表格总结
- "是否需要继续..."
- "建议..."
- "如需..."

## 脚本命令

### 获取下一个模块
```bash
python3 .claude/skills/f2r-check/scripts/next_module.py              # 全局推荐
python3 .claude/skills/f2r-check/scripts/next_module.py --path START # 从 START 追踪
```

### Phase 1 检查
```bash
# 快速检查
python3 .claude/skills/f2r-check/scripts/f2r_check.py START

# 详细差异报告（含风险标记）
python3 .claude/skills/f2r-check/scripts/f2r_check.py --diff START

# 风险评估
python3 .claude/skills/f2r-check/scripts/f2r_check.py --risk START

# 随机审计 5 个 match 模块
python3 .claude/skills/f2r-check/scripts/f2r_check.py --audit
```

### Phase 2 辅助工具
```bash
# 查看模块使用的 COMMON 变量映射
python3 .claude/skills/f2r-check/scripts/common_db.py --module ODFHYS

# 查看 COMMON 块定义
python3 .claude/skills/f2r-check/scripts/common_db.py --block ODFCTR

# 生成深度检查文件列表
python3 .claude/skills/f2r-check/scripts/deep_check_prompt.py ODFHYS

# 查看映射统计
python3 .claude/skills/f2r-check/scripts/common_db.py --mapping
```

## 状态处理

| 状态 | 行动 | 输出 | 允许跳过？ |
|------|------|------|------------|
| ✅ match (无风险) | 跳过 | "模块已完整，跳过" | ✅ |
| ✅ match (有风险) | Phase 2 | "风险: 2 HIGH → 深度检查" | ❌ |
| ⚠️ partial | 立即修复 | "修复: 添加缺失调用..." | ❌ |
| ❌ mismatch | 立即修复 | "修复: 修正逻辑..." | ❌ |
| ❓ missing | 立即实现 | "修复: 实现模块..." | ❌ |

## 修复原则

1. **严格对照 Fortran**: 按 Fortran 代码行号，逐行对比 Rust 实现
2. **保持调用顺序**: Fortran 中的 CALL 顺序必须严格保持
3. **正确映射 COMMON**: Fortran COMMON 块变量 → Rust 结构体字段
   - 使用 `common_db.py --module <NAME>` 查看映射
4. **控制流程等价**: IF/DO/SELECT CASE 逻辑必须一致
5. **数组下标转换**: Fortran 列主序 → Rust 行主序，1-based → 0-based
6. **复杂模块分解**: 遇到复杂模块，分步骤修复，每步验证编译

## 文件路径

- Fortran: `/home/fmq/program/tlusty/tl208-s54/rust/tlusty/extracted/`
- Rust: `/home/fmq/.zeroclaw/workspace/SpectraRust/src/`
- COMMON 定义: `/home/fmq/program/tlusty/tl208-s54/tlusty/*.FOR`
- Rust struct: `/home/fmq/.zeroclaw/workspace/SpectraRust/src/tlusty/state/`

## 脚本修复规则

**重要**：如果发现脚本报告有误（误报），必须修复脚本！

### 脚本误报类型

| 误报类型 | 原因 | 修复方法 |
|----------|------|----------|
| 函数别名未识别 | `COMPT0` vs `compt0_brte` | 添加到 `FUNCTION_ALIASES` |
| 注释 I/O 被检测 | `c write(...)` 被当作必须实现 | 已修复：忽略注释行 |
| 辅助函数调用未检测 | 主函数调用辅助函数，辅助函数包含关键调用 | 已修复：扫描整个文件 |

### 如何修复脚本

1. **添加函数别名**：编辑 `scripts/f2r_check.py`，在 `FUNCTION_ALIASES` 字典中添加
2. **添加调用提取模式**：在 `call_patterns` 列表中添加新模式
3. **修复后验证**：`python3 f2r_check.py --diff <MODULE>`

## 风险检测器说明

### 检测器 A: 2D 数组转置风险
扫描 INCLUDE 文件中的 2D 数组声明（如 `XDO(3,MHOD)`），
标记所有访问该数组的模块需要验证下标顺序。

### 检测器 B: 跨 COMMON 变量混淆
检测已知的易混淆变量对（如 JNDODF vs IJTF），
当模块同时使用这些变量时标记。

### 检测器 C: f2r_depends 诚实性检查
对比 `// f2r_depends:` 注释中声明的函数 vs 代码中实际的调用，
标记声明了但未实际调用的函数。

### 检测器 D: 索引累加器模式
检测 `IJ00=1`, `IJQ=IJ00+IJ` 等索引算术模式，
标记需要验证 1-based → 0-based 转换。