rusty-cpp 0.1.0

A Rust-based static analyzer that applies Rust's ownership and borrowing rules to C++ code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# Test Suite Summary

## Test Results
- **Unit Tests**: 29 passed, 0 failed
- **Integration Tests**: 9 passed, 0 failed, 2 ignored (not yet implemented features)

## New Tests Added for Reference Borrow Checking

### Unit Tests (src/analysis/mod.rs)
1. `test_const_reference_cannot_modify` - Verifies const references cannot be used for assignment
2. `test_mutable_reference_can_modify` - Confirms mutable references allow modification
3. `test_cannot_move_from_reference` - Ensures moves from references are prevented
4. `test_multiple_const_references_allowed` - Validates multiple const refs are allowed
5. `test_multiple_functions_with_references` - Tests cross-function borrow checking
6. `test_complex_borrow_chain` - Tests complex borrowing scenarios

### Integration Tests (tests/integration_test.rs)
1. `test_multiple_mutable_borrows` - **Enabled** (was ignored) - Detects multiple mutable refs
2. `test_const_references_allowed` - Multiple const references should work
3. `test_mixed_const_and_mutable_refs` - Detects const + mutable ref conflicts
4. `test_mutable_then_const_refs` - Detects mutable + const ref conflicts
5. `test_reference_to_reference` - Tests reference aliasing
6. `test_const_ref_assignment_detection` - Validates const ref handling

## Running Tests
```bash
# Set environment variables
export DYLD_LIBRARY_PATH="/opt/homebrew/Cellar/llvm/19.1.7/lib:$DYLD_LIBRARY_PATH"
export Z3_SYS_Z3_HEADER="/opt/homebrew/include/z3.h"

# Run all tests
cargo test

# Run specific test
cargo test test_multiple_mutable_borrows

# Run with output
cargo test -- --nocapture
```

## Still Ignored Tests
1. `test_use_after_move_detection` - Requires std::unique_ptr support
2. `test_dangling_reference` - Requires lifetime analysis implementation

## Test Coverage Areas
- ✅ Multiple immutable borrows
- ✅ Single mutable borrow enforcement
- ✅ Mixed mutable/immutable borrow detection
- ✅ Const reference immutability
- ✅ Move from reference prevention
- ✅ Cross-function analysis
- ⏳ Use-after-move with smart pointers
- ⏳ Dangling reference detection