udo/capy-bearer
Private
Public Access
0
0 Fork 0
Code Releases 1 Activity

Replace serialized dval payloads with live core DValue pointers.

Browse Source
This commit is contained in:
root committed 2026-10-01 21:57:36 +00:00
1 parent b796d9b4e0
commit 97d7178771
14 files changed
+1314 -1160
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

scripts/test_capy_native_compiler.cpp
+16 -16
View File
@@ -170,12 +170,12 @@ int main()
"function CLI(request : dval) { var value := Reflected(s32(1)); print(value::type_name, value::size, value::items.count.value, s64(1)::type_name) }\n", options);
const std::string reflection_bytes(reflection.wasm.begin(), reflection.wasm.end());
assert(capy::wasm::validate_bearer_unit(reflection.wasm, {.bearer_abi_version = "11"}).valid);
assert(reflection_bytes.find("bearer_capy_reflect_struct_brrb") != std::string::npos && reflection_bytes.find("Reflected") != std::string::npos);
assert(reflection_bytes.find("bearer_capy_reflect_struct") != std::string::npos && reflection_bytes.find("Reflected") != std::string::npos);
const auto metadata_only = capy::compile_bearer_unit(
"struct MetadataOnly { count : s32 }\nfunction CLI(request : dval) {}\n", options);
const std::string metadata_only_bytes(metadata_only.wasm.begin(), metadata_only.wasm.end());
assert(metadata_only_bytes.find("MetadataOnly") != std::string::npos && metadata_only_bytes.find("count") != std::string::npos);
assert(metadata_only_bytes.find("bearer_capy_reflect_struct_brrb") == std::string::npos);
assert(metadata_only_bytes.find("bearer_capy_reflect_struct") == std::string::npos);
for (const auto& [source, expected] : {
std::pair{"function f(min : any, max : min::type) min::type { -> min }\nfunction CLI(request : dval) { f(1, \"x\") }\n", "no overload f"},
std::pair{"function CLI(request : dval) { gen_noise(s32(0), s32(1), u64(1), u64(2)) }\n", "no overload __gen_noise"},
@@ -233,7 +233,7 @@ int main()
assert(dval_defaults.wasm == dval_defaults_repeat.wasm && dval_defaults.source_map == dval_defaults_repeat.source_map);
assert(dval_defaults.source_map.find("\t2\t") != std::string::npos);
const std::string dval_default_bytes(dval_defaults.wasm.begin(), dval_defaults.wasm.end());
assert(dval_default_bytes.find("bearer_dv_build_brrb") != std::string::npos);
assert(dval_default_bytes.find("bearer_dv_build") != std::string::npos);
const auto exact_before_default = capy::compile_bearer_unit(
"function select(value : s32) s32 { -> 1 }\nfunction select(value : s32, suffix : string = \"x\") s32 { -> 2 }\nfunction CLI(request : dval) { print(select(1)) }\n", options);
assert(capy::wasm::validate_bearer_unit(exact_before_default.wasm, {.bearer_abi_version = "11"}).valid);
@@ -385,14 +385,14 @@ int main()
assert(capy::wasm::validate_bearer_unit(bare_dval.wasm, {.bearer_abi_version = "11"}).valid);
assert(bare_dval.wasm == bare_dval_repeat.wasm && bare_dval.source_map == bare_dval_repeat.source_map);
const std::string bare_dval_bytes(bare_dval.wasm.begin(), bare_dval.wasm.end());
assert(bare_dval_bytes.find("bearer_dv_build_brrb") != std::string::npos);
assert(bare_dval_bytes.find("bearer_dv_read_brrb") != std::string::npos);
assert(bare_dval_bytes.find("bearer_dv_get_brrb") != std::string::npos);
assert(bare_dval_bytes.find("bearer_dv_build") != std::string::npos);
assert(bare_dval_bytes.find("bearer_dv_read") != std::string::npos);
assert(bare_dval_bytes.find("bearer_dv_has") != std::string::npos);
assert(bare_dval.source_map.find("\t3\t19\n") != std::string::npos);
const auto dval_has_only = capy::compile_bearer_unit("function CLI(request : dval) { var value := {}; print(has(value, \"key\")) }\n", options);
const std::string dval_has_only_bytes(dval_has_only.wasm.begin(), dval_has_only.wasm.end());
assert(dval_has_only_bytes.find("bearer_dv_get_brrb") != std::string::npos);
assert(dval_has_only_bytes.find("bearer_dv_read_brrb") == std::string::npos);
assert(dval_has_only_bytes.find("bearer_dv_has") != std::string::npos);
assert(dval_has_only_bytes.find("bearer_dv_read") == std::string::npos);
const auto dval_none_and_paths = capy::compile_bearer_unit(
"function selector() string { -> \"key\" }\nfunction replacement() string { -> \"value\" }\n"
"function CLI(request : dval) { var value := {items: [{}]}; var missing := value.missing; var absent := missing?; value.items[0][selector()].name = replacement(); print(value.items[0][\"key\"].name, absent, arc_live()) }\n", options);
@@ -403,13 +403,13 @@ int main()
assert(dval_none_and_paths_validation.valid && dval_none_and_paths.wasm == dval_none_and_paths_repeat.wasm && dval_none_and_paths.source_map == dval_none_and_paths_repeat.source_map);
std::set<std::string> dval_path_imports;
for (const auto& imported : dval_none_and_paths_validation.imports) dval_path_imports.insert(imported.name);
for (const char* name : {"bearer_dv_read_brrb", "bearer_dv_is_none_brrb", "bearer_dv_set_path_brrb", "bearer_dv_string_to_brrb", "bearer_dv_s32_to_brrb"}) assert(dval_path_imports.contains(name));
assert(!dval_path_imports.contains("bearer_dv_s64_to_brrb"));
for (const char* name : {"bearer_dv_read", "bearer_dv_is_none", "bearer_dv_set_path", "bearer_dv_string", "bearer_dv_s32"}) assert(dval_path_imports.contains(name));
assert(!dval_path_imports.contains("bearer_dv_s64"));
const auto none_literal = capy::compile_bearer_unit("function CLI(request : dval) { var value := none; print(value?) }\n", options);
assert(capy::wasm::validate_bearer_unit(none_literal.wasm, {.bearer_abi_version = "11"}).valid);
const std::string none_literal_bytes(none_literal.wasm.begin(), none_literal.wasm.end());
assert(none_literal_bytes.find("bearer_dv_none_brrb") != std::string::npos);
for (const char* unrelated : {"bearer_dv_get_brrb", "bearer_dv_read_brrb", "bearer_dv_string_to_brrb", "bearer_dv_s32_to_brrb"})
assert(none_literal_bytes.find("bearer_dv_none") != std::string::npos);
for (const char* unrelated : {"bearer_dv_has", "bearer_dv_read", "bearer_dv_string", "bearer_dv_s32"})
assert(none_literal_bytes.find(unrelated) == std::string::npos);
const auto mutable_dval_roots = capy::compile_bearer_unit(
"function write(value : dval) { value.key = 1; var closure := function() void { value.captured = 2 }; closure() }\n"
@@ -430,7 +430,7 @@ int main()
const auto empty_bare_dval = capy::compile_bearer_unit("function CLI(request : dval) { var value := {}; dval({}); {} }\n", options);
assert(capy::wasm::validate_bearer_unit(empty_bare_dval.wasm, {.bearer_abi_version = "11"}).valid);
const std::string empty_bare_dval_bytes(empty_bare_dval.wasm.begin(), empty_bare_dval.wasm.end());
assert(empty_bare_dval_bytes.find("bearer_dv_build_brrb") != std::string::npos);
assert(empty_bare_dval_bytes.find("bearer_dv_build") != std::string::npos);
const auto dval_member_method = capy::compile_bearer_unit(
"function take(receiver : dval) dval { -> receiver }\nfunction CLI(request : dval) { var value := {}; value.take() }\n", options);
assert(capy::wasm::validate_bearer_unit(dval_member_method.wasm, {.bearer_abi_version = "11"}).valid);
@@ -442,7 +442,7 @@ int main()
"function accept(value : as dval) dval { -> value }\n"
"function CLI(request : dval) { var a := accept(\"x\"); var b := accept(2); var c := accept(s64(-3)); var d := accept(u64(4)); var e := accept(5.5); var f := accept(true) }\n", options);
const std::string converted_dval_bytes(converted_dvals.wasm.begin(), converted_dvals.wasm.end());
for (const std::string& import : {"bearer_dv_string_to_brrb", "bearer_dv_s64_to_brrb", "bearer_dv_u64_to_brrb", "bearer_dv_f64_to_brrb", "bearer_dv_bool_to_brrb"})
for (const std::string& import : {"bearer_dv_string", "bearer_dv_s64", "bearer_dv_u64", "bearer_dv_f64", "bearer_dv_bool"})
assert(converted_dval_bytes.find(import) != std::string::npos);
const auto stdlib_converted_dvals = capy::compile_bearer_unit(
"function CLI(request : dval) { var a := dval(\"x\"); var b := dval(1); var c := push(dval([]), u64(2)); var d := set({}, \"ok\", true); "
@@ -458,7 +458,7 @@ int main()
const auto generic_before_dval = capy::compile_bearer_unit(
"function choose(value : any) string { -> \"generic\" }\nfunction choose(value : as dval) string { -> \"dval\" }\nfunction CLI(request : dval) { print(choose(1)) }\n", options);
const std::string generic_before_dval_bytes(generic_before_dval.wasm.begin(), generic_before_dval.wasm.end());
assert(generic_before_dval_bytes.find("bearer_dv_s32_to_brrb") == std::string::npos);
assert(generic_before_dval_bytes.find("bearer_dv_s32") == std::string::npos);
for (const char* source : {
"function accept(value : as dval) dval { -> value }\nfunction CLI(request : dval) { accept([1]) }\n",
"struct Value { item : s32 }\nfunction accept(value : as dval) dval { -> value }\nfunction CLI(request : dval) { accept(Value(1)) }\n",
@@ -586,7 +586,7 @@ int main()
assert(capy::wasm::validate_bearer_unit(imported_types.wasm, {.bearer_abi_version = "11"}).valid);
const std::string imported_type_bytes(imported_types.wasm.begin(), imported_types.wasm.end());
assert(imported_type_bytes.find("Shape") != std::string::npos && imported_type_bytes.find("value") != std::string::npos);
assert(imported_type_bytes.find("bearer_capy_reflect_struct_brrb") == std::string::npos);
assert(imported_type_bytes.find("bearer_capy_reflect_struct") == std::string::npos);
for (const auto& [source, expected] : {
std::pair{"#exports missing\nfunction CLI(request : dval) {}\n", "unknown local function or type 'missing'"},
std::pair{"#exports invoke\nfunction EXPORT_invoke(value : dval) dval { -> value }\nfunction CLI(request : dval) {}\n", "already declared"},