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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Tests for string handling in HIR (DECY-025 RED phase).
//!
//! Tests for representing C string literals and char* types in HIR,
//! with plans to transpile to Rust &str and String types.

use super::*;

#[test]
fn test_create_string_literal_expression() {
    // C: "hello"
    // Rust: "hello"
    let string_lit = HirExpression::StringLiteral("hello".to_string());

    match string_lit {
        HirExpression::StringLiteral(s) => {
            assert_eq!(s, "hello");
        }
        _ => panic!("Expected StringLiteral"),
    }
}

#[test]
fn test_string_literal_with_escapes() {
    // C: "hello\nworld"
    // Rust: "hello\nworld"
    let string_lit = HirExpression::StringLiteral("hello\\nworld".to_string());

    match string_lit {
        HirExpression::StringLiteral(s) => {
            assert_eq!(s, "hello\\nworld");
        }
        _ => panic!("Expected StringLiteral"),
    }
}

#[test]
fn test_empty_string_literal() {
    // C: ""
    // Rust: ""
    let string_lit = HirExpression::StringLiteral(String::new());

    match string_lit {
        HirExpression::StringLiteral(s) => {
            assert!(s.is_empty());
        }
        _ => panic!("Expected StringLiteral"),
    }
}

#[test]
fn test_char_pointer_type_for_owned_string() {
    // C: char* str
    // Could be Rust: String (owned) or &str (borrowed)
    // For now we need to represent this in HIR
    let char_ptr = HirType::Pointer(Box::new(HirType::Char));

    match char_ptr {
        HirType::Pointer(inner) => {
            assert_eq!(*inner, HirType::Char);
        }
        _ => panic!("Expected Pointer type"),
    }
}

#[test]
fn test_string_variable_declaration() {
    // C: char* message = "Hello";
    // Rust: let message: &str = "Hello";
    let var_decl = HirStatement::VariableDeclaration {
        name: "message".to_string(),
        var_type: HirType::Pointer(Box::new(HirType::Char)),
        initializer: Some(HirExpression::StringLiteral("Hello".to_string())),
    };

    match var_decl {
        HirStatement::VariableDeclaration { name, var_type, initializer } => {
            assert_eq!(name, "message");
            assert!(matches!(var_type, HirType::Pointer(_)));
            assert!(initializer.is_some());
        }
        _ => panic!("Expected VariableDeclaration"),
    }
}

#[test]
fn test_const_char_pointer_type() {
    // C: const char* str
    // Should become Rust: &str (immutable string slice)
    // We need a way to represent const-ness
    let const_char_ptr = HirType::Pointer(Box::new(HirType::Char));

    // For now, we're representing const char* as Pointer(Char)
    // Future: add const qualifier to HirType
    match const_char_ptr {
        HirType::Pointer(inner) => {
            assert_eq!(*inner, HirType::Char);
        }
        _ => panic!("Expected Pointer type"),
    }
}

#[test]
fn test_string_literal_clone() {
    let string_lit = HirExpression::StringLiteral("test".to_string());
    let cloned = string_lit.clone();

    assert_eq!(string_lit, cloned);
}

#[test]
fn test_string_literal_equality() {
    let string_lit1 = HirExpression::StringLiteral("test".to_string());
    let string_lit2 = HirExpression::StringLiteral("test".to_string());

    assert_eq!(string_lit1, string_lit2);
}

#[test]
fn test_string_function_parameter() {
    // C: void print_message(const char* msg);
    // Rust: fn print_message(msg: &str);
    let param = HirParameter::new("msg".to_string(), HirType::Pointer(Box::new(HirType::Char)));

    assert_eq!(param.name(), "msg");
    assert!(matches!(param.param_type(), HirType::Pointer(_)));
}

#[test]
fn test_string_return_type() {
    // C: const char* get_name();
    // Rust: fn get_name() -> &str;
    let func =
        HirFunction::new("get_name".to_string(), HirType::Pointer(Box::new(HirType::Char)), vec![]);

    assert_eq!(func.name(), "get_name");
    assert!(matches!(func.return_type(), HirType::Pointer(_)));
}