Initial commit

2025-11-29 18:25:55 +08:00
commit d8b4535ddb
15 changed files with 4992 additions and 0 deletions
--- a/commands/rust-modernize.md
+++ b/commands/rust-modernize.md
@@ -0,0 +1,346 @@
+---
+description: Analyze and modernize Rust code to use latest features and patterns
+---
+
+You are helping modernize Rust code to use the latest features from Rust 2024 Edition.
+
+## Your Task
+
+Analyze Rust code and refactor it to use modern patterns including let chains, async closures, improved match ergonomics, and other Rust 2024 features.
+
+## Steps
+
+1. **Scan for Modernization Opportunities**
+
+   Look for these patterns that can be modernized:
+   - Nested if-let statements → let chains
+   - Manual async closures → native async closures
+   - Old match patterns → improved match ergonomics
+   - Regular functions → const functions where possible
+   - Manual iterators → gen blocks
+   - Complex error propagation → cleaner patterns
+
+2. **Categorize Findings**
+
+   Group by modernization type:
+   ```
+   Modernization Opportunities Found:
+
+   Let Chains (5):
+   - src/user.rs:42 - Nested if-let (3 levels deep)
+   - src/api.rs:15 - Multiple Option checks
+   ...
+
+   Async Closures (3):
+   - src/tasks.rs:28 - Manual async wrapper
+   ...
+
+   Const Opportunities (2):
+   - src/config.rs:10 - Function could be const
+   ...
+   ```
+
+3. **Ask User for Scope**
+
+   Ask which modernizations to apply:
+   - All recommended changes?
+   - Specific category (let chains, async, etc.)?
+   - Specific file or function?
+
+4. **Refactor Pattern: Nested If-Let → Let Chains**
+
+   **Before:**
+   ```rust
+   if let Some(user) = get_user(id) {
+       if let Some(profile) = user.profile {
+           if profile.is_active {
+               if let Some(email) = profile.email {
+                   send_email(&email);
+               }
+           }
+       }
+   }
+   ```
+
+   **After:**
+   ```rust
+   if let Some(user) = get_user(id)
+       && let Some(profile) = user.profile
+       && profile.is_active
+       && let Some(email) = profile.email
+   {
+       send_email(&email);
+   }
+   ```
+
+5. **Refactor Pattern: Manual Async → Async Closures**
+
+   **Before:**
+   ```rust
+   let futures: Vec<_> = items
+       .iter()
+       .map(|item| {
+           let item = item.clone();
+           async move {
+               process_item(item).await
+           }
+       })
+       .collect();
+   ```
+
+   **After:**
+   ```rust
+   let futures: Vec<_> = items
+       .iter()
+       .map(async |item| {
+           process_item(item).await
+       })
+       .collect();
+   ```
+
+6. **Refactor Pattern: Functions → Const Functions**
+
+   **Before:**
+   ```rust
+   fn calculate_buffer_size(items: usize) -> usize {
+       items * std::mem::size_of::<Item>()
+   }
+
+   static BUFFER: [u8; calculate_buffer_size(100)]; // Error!
+   ```
+
+   **After:**
+   ```rust
+   const fn calculate_buffer_size(items: usize) -> usize {
+       items * std::mem::size_of::<Item>()
+   }
+
+   const BUFFER_SIZE: usize = calculate_buffer_size(100);
+   static BUFFER: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
+   ```
+
+7. **Refactor Pattern: Manual Iterator → Gen Block**
+
+   **Before:**
+   ```rust
+   struct FibIterator {
+       a: u64,
+       b: u64,
+   }
+
+   impl Iterator for FibIterator {
+       type Item = u64;
+
+       fn next(&mut self) -> Option<Self::Item> {
+           let current = self.a;
+           self.a = self.b;
+           self.b = current + self.b;
+           Some(current)
+       }
+   }
+
+   fn fibonacci() -> FibIterator {
+       FibIterator { a: 0, b: 1 }
+   }
+   ```
+
+   **After:**
+   ```rust
+   fn fibonacci() -> impl Iterator<Item = u64> {
+       gen {
+           let (mut a, mut b) = (0, 1);
+           loop {
+               yield a;
+               (a, b) = (b, a + b);
+           }
+       }
+   }
+   ```
+
+8. **Refactor Pattern: Match Ergonomics**
+
+   **Before (Rust 2021):**
+   ```rust
+   match &option {
+       Some(x) => {
+           // x is &T, need to clone or handle reference
+           process(x.clone());
+       }
+       None => {}
+   }
+   ```
+
+   **After (Rust 2024):**
+   ```rust
+   match &option {
+       Some(mut x) => {
+           // x is &mut T (not moved), can modify in place
+           x.update();
+       }
+       None => {}
+   }
+   ```
+
+9. **Check Edition and Version**
+
+   Ensure project supports modern features:
+
+   ```toml
+   [package]
+   edition = "2024"
+   rust-version = "1.85"  # For full 2024 support
+   ```
+
+   If edition needs updating:
+   - Ask user if they want to upgrade
+   - Run `cargo fix --edition` after updating
+   - Check for breaking changes
+
+10. **Provide Modernization Summary**
+
+    ```
+    ✅ Code modernized successfully!
+
+    ## Changes Made:
+
+    ### Let Chains (5 locations):
+    - src/user.rs:42 - Flattened 3-level nesting
+    - src/api.rs:15 - Combined Option checks
+    - src/validate.rs:88 - Simplified Result handling
+
+    ### Async Closures (3 locations):
+    - src/tasks.rs:28 - Replaced manual async wrapper
+    - src/jobs.rs:45 - Simplified async map
+    - src/handlers.rs:102 - Cleaner async callback
+
+    ### Const Functions (2 locations):
+    - src/config.rs:10 - Made calculate_size const
+    - src/utils.rs:25 - Made hash_string const
+
+    ### Gen Blocks (1 location):
+    - src/iter.rs:15 - Simplified iterator with gen block
+
+    ## Edition Status:
+    - Current: edition = "2024" ✅
+    - MSRV: rust-version = "1.85" ✅
+
+    ## Before/After Example:
+
+    Before:
+    ```rust
+    if let Some(user) = get_user() {
+        if let Some(email) = user.email {
+            if email.contains('@') {
+                send_email(&email);
+            }
+        }
+    }
+    ```
+
+    After:
+    ```rust
+    if let Some(user) = get_user()
+        && let Some(email) = user.email
+        && email.contains('@')
+    {
+        send_email(&email);
+    }
+    ```
+
+    ## Next Steps:
+    1. Run tests: `cargo test`
+    2. Check for warnings: `cargo check`
+    3. Review changes for correctness
+    4. Consider enabling more lints for modern patterns
+
+    ## Suggested Lints:
+    Add to Cargo.toml or lib.rs:
+    ```rust
+    #![warn(rust_2024_compatibility)]
+    #![warn(let_underscore_drop)]
+    ```
+    ```
+
+## Modernization Patterns
+
+### Let Chains
+
+Look for:
+- Multiple nested if-let
+- if-let followed by if condition
+- while-let with additional conditions
+
+Convert to:
+```rust
+if let Pattern1 = expr1
+    && let Pattern2 = expr2
+    && boolean_condition
+{
+    // body
+}
+```
+
+### Async Closures
+
+Look for:
+- `.map(|x| { let x = x.clone(); async move { ... } })`
+- Manual future wrapping
+- Complex async callback patterns
+
+Convert to:
+```rust
+.map(async |x| { ... })
+```
+
+### Const Functions
+
+Look for:
+- Functions with only const-safe operations
+- Compile-time computations
+- Functions used in const contexts
+
+Convert to:
+```rust
+const fn function_name(...) -> ReturnType {
+    // const-safe operations only
+}
+```
+
+### Gen Blocks
+
+Look for:
+- Manual Iterator implementations
+- State machines for iteration
+- Complex iteration logic
+
+Convert to:
+```rust
+gen {
+    // yield values
+}
+```
+
+## Important Notes
+
+- Only apply changes if edition = "2024" or offer to upgrade
+- Test thoroughly after modernization
+- Some patterns require minimum Rust versions
+- Preserve behavior - modernization should not change logic
+- Document breaking changes if any
+
+## Version Requirements
+
+| Feature | Min Rust Version | Edition |
+|---------|-----------------|---------|
+| Let chains | 1.88.0 | 2024 |
+| Async closures | 1.85.0 | 2024 |
+| Gen blocks | 1.85.0 | 2024 |
+| Match ergonomics | 1.85.0 | 2024 |
+
+## After Completion
+
+Ask the user:
+1. Did all tests pass?
+2. Are there more files to modernize?
+3. Should we enable additional lints?
+4. Do you want to update documentation?