buffa-codegen 0.7.1

Shared code generation logic for buffa (descriptor → Rust source)
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

//! Vtable-mode reflection codegen: config validation and emitted impls.

use super::*;
use crate::ReflectMode;

#[test]
fn reflect_mode_maps_to_config_flags() {
    let mut c = CodeGenConfig::default();

    ReflectMode::Off.apply(&mut c);
    assert!(!c.generate_reflection && !c.generate_reflection_vtable);

    ReflectMode::Bridge.apply(&mut c);
    assert!(c.generate_reflection && !c.generate_reflection_vtable);

    ReflectMode::VTable.apply(&mut c);
    assert!(c.generate_reflection && c.generate_reflection_vtable);
}

/// A config with both bridge reflection and vtable mode enabled.
fn vtable_config() -> CodeGenConfig {
    CodeGenConfig {
        generate_reflection: true,
        generate_reflection_vtable: true,
        ..Default::default()
    }
}

/// A small proto3 message with a scalar and a string field.
fn msg_file() -> FileDescriptorProto {
    let mut file = proto3_file("vt.proto");
    file.message_type.push(DescriptorProto {
        name: Some("Msg".to_string()),
        field: vec![
            make_field("id", 1, Label::LABEL_OPTIONAL, Type::TYPE_INT32),
            make_field("name", 2, Label::LABEL_OPTIONAL, Type::TYPE_STRING),
        ],
        ..Default::default()
    });
    file
}

#[test]
fn vtable_emits_reflect_message_and_element_impls() {
    let files = generate(&[msg_file()], &["vt.proto".to_string()], &vtable_config())
        .expect("should generate");
    let content = joined(&files);

    assert!(
        content.contains("impl<'a> ::buffa_descriptor::reflect::ReflectMessage for MsgView<'a>"),
        "vtable mode must emit ReflectMessage for the view: {content}"
    );
    assert!(
        content.contains("impl<'a> ::buffa_descriptor::reflect::ReflectElement for MsgView<'a>"),
        "vtable mode must emit ReflectElement for the view: {content}"
    );
    // The memoized index accessor is an inherent associated fn (collision-free
    // across sibling views).
    assert!(
        content.contains("fn __buffa_reflect_message_index()"),
        "vtable mode must emit the memoized MessageIndex accessor: {content}"
    );
}

#[test]
fn vtable_without_reflection_is_rejected() {
    let config = CodeGenConfig {
        generate_reflection: false,
        generate_reflection_vtable: true,
        ..Default::default()
    };
    let err = generate(&[msg_file()], &["vt.proto".to_string()], &config)
        .expect_err("vtable without reflection must error");
    assert!(
        err.to_string().contains("generate_reflection"),
        "error should name the missing prerequisite: {err}"
    );
}

#[test]
fn vtable_without_views_emits_owned_only() {
    // Owned vtable is self-contained, so views-off + vtable is allowed: it
    // emits the owned `impl ReflectMessage` but no view impls (there are no
    // views).
    let config = CodeGenConfig {
        generate_reflection: true,
        generate_reflection_vtable: true,
        generate_views: false,
        ..Default::default()
    };
    let files =
        generate(&[msg_file()], &["vt.proto".to_string()], &config).expect("should generate");
    let content = joined(&files);
    assert!(
        content.contains("impl ::buffa_descriptor::reflect::ReflectMessage for Msg"),
        "owned ReflectMessage must be emitted: {content}"
    );
    assert!(
        !content.contains("ReflectMessage for MsgView"),
        "no view impls when views are off: {content}"
    );
}

#[test]
fn bridge_only_does_not_emit_vtable_impls() {
    let config = CodeGenConfig {
        generate_reflection: true,
        generate_reflection_vtable: false,
        ..Default::default()
    };
    let files =
        generate(&[msg_file()], &["vt.proto".to_string()], &config).expect("should generate");
    let content = joined(&files);
    // Bridge mode emits Reflectable on the owned type but no ReflectMessage on
    // the view.
    assert!(
        content.contains("impl ::buffa_descriptor::reflect::Reflectable for Msg"),
        "bridge mode must still emit Reflectable: {content}"
    );
    assert!(
        !content.contains("ReflectMessage for MsgView"),
        "bridge-only must not emit the vtable ReflectMessage impl: {content}"
    );
}