alef 0.83.1

Opinionated polyglot binding generator for Rust libraries
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

use std::collections::HashMap;

use crate::e2e::field_access::FieldResolver;
use crate::e2e::fixture::Assertion;

/// Whether `path`'s FINAL segment is an indexed array element (`foo[0]`) rather than the
/// collection itself.
///
/// ~keep Mirrors `FieldResolver::rust_unwrap_binding`'s `leaf_is_indexed_element`: `is_optional`/
/// `is_array`/`target_field_is_pointer` all resolve a field NAME after bracket-stripping (via
/// `parse_path`/`segment_name`), so `detected_languages` and `detected_languages[0]` answer
/// IDENTICALLY -- both report whatever `Option<Vec<String>>` says about the COLLECTION. That is
/// correct for the bare collection but wrong for an element already reached through an index: a
/// trailing `[0]` has already consumed the container's own optionality (a valid index only exists
/// once the `Option` and the slice are non-empty), so the element itself is a concrete `string`,
/// never nilable. Without this guard `resolve_assertion_field_shape` pushed the collection's
/// `is_optional` onto the element, producing `result.DetectedLanguages[0] == nil` against a plain
/// Go `string` -- `invalid operation: mismatched types string and untyped nil`.
fn leaf_is_indexed_element(path: &str) -> bool {
    let Some(open) = path.rfind('[') else {
        return false;
    };
    path.ends_with(']')
        && open + 1 < path.len() - 1
        && path[open + 1..path.len() - 1].bytes().all(|b| b.is_ascii_digit())
}

/// Whether `path`'s FINAL segment is a map-key lookup (`open_graph[title]`) rather than a
/// numeric array index -- the sibling shape [`leaf_is_indexed_element`] does not cover.
///
/// A map key lookup is bracket syntax exactly like an array index, but it can only ever be
/// declared "optional" for the reason a map key genuinely can be: the key might be absent.
/// That is a real cross-language fact (`fields_optional` on `open_graph[title]` is correct for
/// Python's `.get()`/TypeScript's `undefined`), but it says nothing about whether the Go
/// expression `m["key"]` can be `nil` -- a Go map read, even on a nil map or a missing key,
/// always yields the value type's zero value. Whether that zero value can itself be `nil`
/// depends only on the map's VALUE type, which `resolve_assertion_field_shape` checks
/// separately via `FieldResolver::map_value_is_scalar` before trusting this leaf shape to
/// suppress the container's declared optionality.
fn leaf_is_map_key_element(path: &str) -> bool {
    let Some(open) = path.rfind('[') else {
        return false;
    };
    path.ends_with(']')
        && open + 1 < path.len() - 1
        && !path[open + 1..path.len() - 1].bytes().all(|b| b.is_ascii_digit())
}

pub(super) struct AssertionFieldShape {
    pub is_optional: bool,
    pub is_pointer: bool,
    pub is_nullable: bool,
    pub is_array_for_len: bool,
    pub is_slice: bool,
    pub is_data_interface: bool,
}

pub(super) fn resolve_assertion_field_shape(
    assertion: &Assertion,
    field_resolver: &FieldResolver,
    optional_locals: &HashMap<String, String>,
) -> AssertionFieldShape {
    let Some(field) = assertion.field.as_deref() else {
        return AssertionFieldShape {
            is_optional: false,
            is_pointer: false,
            is_nullable: false,
            is_array_for_len: false,
            is_slice: false,
            is_data_interface: false,
        };
    };
    let resolved = field_resolver.resolve(field);
    let check_path = resolved
        .strip_suffix(".length")
        .or_else(|| resolved.strip_suffix(".count"))
        .or_else(|| resolved.strip_suffix(".size"))
        .unwrap_or(resolved);
    let uses_plain_local = optional_locals.contains_key(field);
    let leaf_is_indexed_element = leaf_is_indexed_element(check_path);
    // A map-key leaf only overrides the container's declared optionality when the IR can
    // positively prove the map's VALUE type is a plain, never-nil Go kind -- `unwrap_or(false)`
    // here is deliberate and asymmetric with the numeric-index case above: an unresolved path
    // must fall through to the existing `is_optional`/`is_pointer` computation unchanged, so a
    // map of pointers or sealed interfaces (or a path the IR simply cannot anchor) keeps
    // whatever nil guard it already had. See `leaf_is_map_key_element` and
    // `FieldResolver::map_value_is_scalar`.
    let leaf_is_scalar_map_value =
        leaf_is_map_key_element(check_path) && field_resolver.map_value_is_scalar(check_path).unwrap_or(false);
    let container_nullability_consumed = leaf_is_indexed_element || leaf_is_scalar_map_value;
    let is_optional = !container_nullability_consumed && field_resolver.is_optional(check_path) && !uses_plain_local;
    let is_array_for_len = !container_nullability_consumed && field_resolver.is_array(check_path);
    let is_slice = !container_nullability_consumed && field_resolver.is_array(resolved);
    // ~keep `target_field_is_pointer` is the authoritative answer: it reads the same
    // `go_struct_field_type` the Go binding backend itself emits from (see
    // `ir_result_fields::pointer_at_path`). `None` means that walk could not resolve `check_path`
    // at all -- NOT "the field is pointer-shaped" -- so guessing `is_optional && !is_array_for_len`
    // here treated a resolution failure as a successful "yes": an `Option<Vec<T>>` result field
    // Go always flattens to a plain nilable slice (never a pointer) got dereferenced as
    // `len(*result.Chunks)`, a Go compile error (`cannot indirect ... variable of type []T`).
    // Defaulting to `false` never adds a spurious `*`; the worst case is a missing deref the IR
    // could not prove was needed, which is a comparison against the wrong Go type and fails to
    // build immediately, rather than silently asserting nothing.
    let is_pointer = !container_nullability_consumed
        && !uses_plain_local
        && field_resolver.target_field_is_pointer(check_path).unwrap_or(false);

    AssertionFieldShape {
        is_optional,
        is_pointer,
        is_nullable: is_optional || is_pointer,
        is_array_for_len,
        is_slice,
        is_data_interface: field_resolver.target_field_is_data_interface(check_path),
    }
}