decy-hir 2.2.0

High-level Intermediate Representation for C-to-Rust transpilation
Documentation 
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Tests for SliceIndex HIR expression.
//!
//! DECY-069: SliceIndex is a safe alternative to pointer arithmetic for array access.
//! Instead of generating unsafe pointer arithmetic (ptr + offset), we generate
//! safe slice indexing (arr[index]).

use crate::{HirExpression, HirType};

// ============================================================================
// DECY-069 RED PHASE: SliceIndex Expression Tests
// ============================================================================

#[test]
fn test_slice_index_creation() {
    // Create SliceIndex expression: arr[5]
    let slice_index = HirExpression::SliceIndex {
        slice: Box::new(HirExpression::Variable("arr".to_string())),
        index: Box::new(HirExpression::IntLiteral(5)),
        element_type: HirType::Int,
    };

    // Should be able to create and match
    if let HirExpression::SliceIndex { slice, index, element_type } = slice_index {
        assert!(matches!(*slice, HirExpression::Variable(_)));
        assert!(matches!(*index, HirExpression::IntLiteral(5)));
        assert_eq!(element_type, HirType::Int);
    } else {
        panic!("Expected SliceIndex variant");
    }
}

#[test]
fn test_slice_index_debug_format() {
    // SliceIndex should have Debug implementation
    let slice_index = HirExpression::SliceIndex {
        slice: Box::new(HirExpression::Variable("arr".to_string())),
        index: Box::new(HirExpression::Variable("i".to_string())),
        element_type: HirType::Int,
    };

    let debug_str = format!("{:?}", slice_index);

    // Debug output should contain key information
    assert!(debug_str.contains("SliceIndex"), "Debug output should mention SliceIndex");
    assert!(
        debug_str.contains("arr") || debug_str.contains("Variable"),
        "Debug output should show slice variable"
    );
}

#[test]
fn test_slice_index_distinguishes_from_array_index() {
    // SliceIndex and ArrayIndex are different variants
    let slice_index = HirExpression::SliceIndex {
        slice: Box::new(HirExpression::Variable("arr".to_string())),
        index: Box::new(HirExpression::IntLiteral(0)),
        element_type: HirType::Int,
    };

    let array_index = HirExpression::ArrayIndex {
        array: Box::new(HirExpression::Variable("arr".to_string())),
        index: Box::new(HirExpression::IntLiteral(0)),
    };

    // They should be different types
    assert!(
        !matches!(slice_index, HirExpression::ArrayIndex { .. }),
        "SliceIndex should not be ArrayIndex"
    );
    assert!(
        !matches!(array_index, HirExpression::SliceIndex { .. }),
        "ArrayIndex should not be SliceIndex"
    );
}

#[test]
fn test_slice_index_with_expression_index() {
    // SliceIndex can use expression as index: arr[i + 1]
    let slice_index = HirExpression::SliceIndex {
        slice: Box::new(HirExpression::Variable("arr".to_string())),
        index: Box::new(HirExpression::BinaryOp {
            op: crate::BinaryOperator::Add,
            left: Box::new(HirExpression::Variable("i".to_string())),
            right: Box::new(HirExpression::IntLiteral(1)),
        }),
        element_type: HirType::Int,
    };

    // Should match and extract components
    if let HirExpression::SliceIndex { index, .. } = slice_index {
        assert!(matches!(*index, HirExpression::BinaryOp { .. }), "Index should be BinaryOp");
    } else {
        panic!("Expected SliceIndex");
    }
}

#[test]
fn test_slice_index_element_type_preserved() {
    // SliceIndex preserves element type for codegen
    let int_slice = HirExpression::SliceIndex {
        slice: Box::new(HirExpression::Variable("int_arr".to_string())),
        index: Box::new(HirExpression::IntLiteral(0)),
        element_type: HirType::Int,
    };

    let float_slice = HirExpression::SliceIndex {
        slice: Box::new(HirExpression::Variable("float_arr".to_string())),
        index: Box::new(HirExpression::IntLiteral(0)),
        element_type: HirType::Float,
    };

    // Element types should be preserved
    if let HirExpression::SliceIndex { element_type, .. } = int_slice {
        assert_eq!(element_type, HirType::Int);
    }

    if let HirExpression::SliceIndex { element_type, .. } = float_slice {
        assert_eq!(element_type, HirType::Float);
    }
}