Lines Matching refs:out
3 use crate::gen::out::OutFile;
19 let out = &mut out_file;
21 pick_includes_and_builtins(out, apis);
22 out.include.extend(&opt.include);
24 write_forward_declarations(out, apis);
25 write_data_structures(out, apis);
26 write_functions(out, apis);
27 write_generic_instantiations(out);
29 builtin::write(out);
30 include::write(out);
35 fn write_forward_declarations(out: &mut OutFile, apis: &[Api]) {
38 Api::Enum(enm) => !out.types.cxx.contains(&enm.name.rust),
45 write(out, &apis_by_namespace, 0);
47 fn write(out: &mut OutFile, ns_entries: &NamespaceEntries, indent: usize) {
51 write!(out, "{:1$}", "", indent);
53 Api::Struct(strct) => write_struct_decl(out, &strct.name),
54 Api::Enum(enm) => write_enum_decl(out, enm),
55 Api::CxxType(ety) => write_struct_using(out, &ety.name),
56 Api::RustType(ety) => write_struct_decl(out, &ety.name),
62 writeln!(out, "{:2$}namespace {} {{", "", namespace, indent);
63 write(out, nested_ns_entries, indent + 2);
64 writeln!(out, "{:1$}}}", "", indent);
69 fn write_data_structures<'a>(out: &mut OutFile<'a>, apis: &'a [Api]) {
83 let mut toposorted_structs = out.types.toposorted_structs.iter();
88 if !out.types.cxx.contains(&strct.name.rust) {
89 out.next_section();
94 write_struct(out, next, methods);
103 out.next_section();
104 if !out.types.cxx.contains(&enm.name.rust) {
105 write_enum(out, enm);
107 check_enum(out, enm);
111 out.next_section();
116 write_opaque_type(out, ety, methods);
122 if out.header {
126 out.set_namespace(Default::default());
128 out.next_section();
131 if let Some(reasons) = out.types.required_trivial.get(&ety.name.rust) {
132 check_trivial_extern_type(out, ety, reasons)
138 fn write_functions<'a>(out: &mut OutFile<'a>, apis: &'a [Api]) {
139 if !out.header {
142 Api::Struct(strct) => write_struct_operator_decls(out, strct),
143 Api::RustType(ety) => write_opaque_type_layout_decls(out, ety),
144 Api::CxxFunction(efn) => write_cxx_function_shim(out, efn),
145 Api::RustFunction(efn) => write_rust_function_decl(out, efn),
150 write_std_specializations(out, apis);
155 Api::Struct(strct) => write_struct_operators(out, strct),
156 Api::RustType(ety) => write_opaque_type_layout(out, ety),
158 out.next_section();
159 write_rust_function_shim(out, efn);
166 fn write_std_specializations(out: &mut OutFile, apis: &[Api]) {
167 out.set_namespace(Default::default());
168 out.begin_block(Block::Namespace("std"));
173 out.next_section();
174 out.include.cstddef = true;
175 out.include.functional = true;
177 writeln!(out, "template <> struct hash<{}> {{", qualified);
179 out,
184 write!(out, " return ::");
186 write!(out, "{}::", name);
188 writeln!(out, "{}(self);", link_name);
189 writeln!(out, " }}");
190 writeln!(out, "}};");
195 out.end_block(Block::Namespace("std"));
198 fn pick_includes_and_builtins(out: &mut OutFile, apis: &[Api]) {
201 out.include.insert(include);
205 for ty in out.types {
209 | Some(I64) => out.include.cstdint = true,
210 Some(Usize) => out.include.cstddef = true,
211 Some(Isize) => out.builtin.rust_isize = true,
212 Some(CxxString) => out.include.string = true,
213 Some(RustString) => out.builtin.rust_string = true,
216 Type::RustBox(_) => out.builtin.rust_box = true,
217 Type::RustVec(_) => out.builtin.rust_vec = true,
218 Type::UniquePtr(_) => out.include.memory = true,
219 Type::SharedPtr(_) | Type::WeakPtr(_) => out.include.memory = true,
220 Type::Str(_) => out.builtin.rust_str = true,
221 Type::CxxVector(_) => out.include.vector = true,
222 Type::Fn(_) => out.builtin.rust_fn = true,
223 Type::SliceRef(_) => out.builtin.rust_slice = true,
224 Type::Array(_) => out.include.array = true,
230 fn write_doc(out: &mut OutFile, indent: &str, doc: &Doc) {
233 if out.opt.doxygen {
234 writeln!(out, "{}///{}", indent, line);
236 writeln!(out, "{}//{}", indent, line);
244 if out.opt.doxygen && lines == 1 {
245 writeln!(out, "{}///", indent);
249 fn write_struct<'a>(out: &mut OutFile<'a>, strct: &'a Struct, methods: &[&ExternFn]) {
253 out.set_namespace(&strct.name.namespace);
255 writeln!(out, "#ifndef {}", guard);
256 writeln!(out, "#define {}", guard);
257 write_doc(out, "", &strct.doc);
258 writeln!(out, "struct {} final {{", strct.name.cxx);
261 write_doc(out, " ", &field.doc);
262 write!(out, " ");
263 write_type_space(out, &field.ty);
264 writeln!(out, "{};", field.name.cxx);
267 out.next_section();
271 out.next_section();
273 write_doc(out, " ", &method.doc);
274 write!(out, " ");
278 write_rust_function_shim_decl(out, &local_name, sig, indirect_call);
279 writeln!(out, ";");
281 out.next_section();
287 out,
292 out,
300 out,
305 out,
310 out,
315 out,
321 out.include.type_traits = true;
322 writeln!(out, " using IsRelocatable = ::std::true_type;");
324 writeln!(out, "}};");
325 writeln!(out, "#endif // {}", guard);
328 fn write_struct_decl(out: &mut OutFile, ident: &Pair) {
329 writeln!(out, "struct {};", ident.cxx);
332 fn write_enum_decl(out: &mut OutFile, enm: &Enum) {
338 write!(out, "enum class {} : ", enm.name.cxx);
339 write_atom(out, repr);
340 writeln!(out, ";");
343 fn write_struct_using(out: &mut OutFile, ident: &Pair) {
344 writeln!(out, "using {} = {};", ident.cxx, ident.to_fully_qualified());
347 fn write_opaque_type<'a>(out: &mut OutFile<'a>, ety: &'a ExternType, methods: &[&ExternFn]) {
348 out.set_namespace(&ety.name.namespace);
350 writeln!(out, "#ifndef {}", guard);
351 writeln!(out, "#define {}", guard);
352 write_doc(out, "", &ety.doc);
354 out.builtin.opaque = true;
356 out,
363 out.next_section();
365 write_doc(out, " ", &method.doc);
366 write!(out, " ");
370 write_rust_function_shim_decl(out, &local_name, sig, indirect_call);
371 writeln!(out, ";");
373 out.next_section();
377 writeln!(out, " ~{}() = delete;", ety.name.cxx);
378 writeln!(out);
380 out.builtin.layout = true;
381 out.include.cstddef = true;
382 writeln!(out, "private:");
383 writeln!(out, " friend ::rust::layout;");
384 writeln!(out, " struct layout {{");
385 writeln!(out, " static ::std::size_t size() noexcept;");
386 writeln!(out, " static ::std::size_t align() noexcept;");
387 writeln!(out, " }};");
388 writeln!(out, "}};");
389 writeln!(out, "#endif // {}", guard);
392 fn write_enum<'a>(out: &mut OutFile<'a>, enm: &'a Enum) {
398 out.set_namespace(&enm.name.namespace);
400 writeln!(out, "#ifndef {}", guard);
401 writeln!(out, "#define {}", guard);
402 write_doc(out, "", &enm.doc);
403 write!(out, "enum class {} : ", enm.name.cxx);
404 write_atom(out, repr);
405 writeln!(out, " {{");
407 write_doc(out, " ", &variant.doc);
408 writeln!(out, " {} = {},", variant.name.cxx, variant.discriminant);
410 writeln!(out, "}};");
411 writeln!(out, "#endif // {}", guard);
414 fn check_enum<'a>(out: &mut OutFile<'a>, enm: &'a Enum) {
420 out.set_namespace(&enm.name.namespace);
421 out.include.type_traits = true;
423 out,
427 write!(out, "static_assert(sizeof({}) == sizeof(", enm.name.cxx);
428 write_atom(out, repr);
429 writeln!(out, "), \"incorrect size\");");
431 write!(out, "static_assert(static_cast<");
432 write_atom(out, repr);
434 out,
441 fn check_trivial_extern_type(out: &mut OutFile, alias: &TypeAlias, reasons: &[TrivialReason]) {
457 // There may be legitimate reasons to opt out of this assertion for support
460 // or destructor. To opt out of the relocatability check, they need to do
476 out.builtin.relocatable = true;
477 writeln!(out, "static_assert(");
492 out.builtin.relocatable_or_array = true;
493 writeln!(out, " ::rust::IsRelocatableOrArray<{}>::value,", id);
495 writeln!(out, " ::rust::IsRelocatable<{}>::value,", id);
498 out,
505 fn write_struct_operator_decls<'a>(out: &mut OutFile<'a>, strct: &'a Struct) {
506 out.set_namespace(&strct.name.namespace);
507 out.begin_block(Block::ExternC);
512 out,
520 out,
530 out,
537 out,
545 out,
552 out,
560 out.include.cstddef = true;
563 out,
569 out.end_block(Block::ExternC);
572 fn write_struct_operators<'a>(out: &mut OutFile<'a>, strct: &'a Struct) {
573 if out.header {
577 out.set_namespace(&strct.name.namespace);
580 out.next_section();
582 out,
587 writeln!(out, " return {}(*this, rhs);", link_name);
588 writeln!(out, "}}");
590 out.next_section();
592 out,
597 writeln!(out, " return !(*this == rhs);");
600 writeln!(out, " return {}(*this, rhs);", link_name);
602 writeln!(out, "}}");
606 out.next_section();
608 out,
613 writeln!(out, " return {}(*this, rhs);", link_name);
614 writeln!(out, "}}");
616 out.next_section();
618 out,
623 writeln!(out, " return {}(*this, rhs);", link_name);
624 writeln!(out, "}}");
626 out.next_section();
628 out,
633 writeln!(out, " return !(*this <= rhs);");
636 writeln!(out, " return {}(*this, rhs);", link_name);
638 writeln!(out, "}}");
640 out.next_section();
642 out,
647 writeln!(out, " return !(*this < rhs);");
650 writeln!(out, " return {}(*this, rhs);", link_name);
652 writeln!(out, "}}");
656 fn write_opaque_type_layout_decls<'a>(out: &mut OutFile<'a>, ety: &'a ExternType) {
657 out.set_namespace(&ety.name.namespace);
658 out.begin_block(Block::ExternC);
661 writeln!(out, "::std::size_t {}() noexcept;", link_name);
664 writeln!(out, "::std::size_t {}() noexcept;", link_name);
666 out.end_block(Block::ExternC);
669 fn write_opaque_type_layout<'a>(out: &mut OutFile<'a>, ety: &'a ExternType) {
670 if out.header {
674 out.set_namespace(&ety.name.namespace);
676 out.next_section();
679 out,
683 writeln!(out, " return {}();", link_name);
684 writeln!(out, "}}");
686 out.next_section();
689 out,
693 writeln!(out, " return {}();", link_name);
694 writeln!(out, "}}");
697 fn begin_function_definition(out: &mut OutFile) {
698 if let Some(annotation) = &out.opt.cxx_impl_annotations {
699 write!(out, "{} ", annotation);
703 fn write_cxx_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
704 out.next_section();
705 out.set_namespace(&efn.name.namespace);
706 out.begin_block(Block::ExternC);
707 begin_function_definition(out);
709 out.builtin.ptr_len = true;
710 write!(out, "::rust::repr::PtrLen ");
712 write_extern_return_type_space(out, &efn.ret);
714 let mangled = mangle::extern_fn(efn, out.types);
715 write!(out, "{}(", mangled);
718 out,
720 out.types.resolve(&receiver.ty).name.to_fully_qualified(),
723 write!(out, " const");
725 write!(out, " &self");
729 write!(out, ", ");
732 write_type_space(out, &arg.ty);
733 write!(out, "const *{}", arg.name.cxx);
735 write_type_space(out, &arg.ty);
736 write!(out, "const *{}", arg.name.cxx);
738 write_extern_arg(out, arg);
741 let indirect_return = indirect_return(efn, out.types);
744 write!(out, ", ");
746 write_indirect_return_type_space(out, efn.ret.as_ref().unwrap());
747 write!(out, "*return$");
749 writeln!(out, ") noexcept {{");
750 write!(out, " ");
751 write_return_type(out, &efn.ret);
753 None => write!(out, "(*{}$)(", efn.name.rust),
755 out,
757 out.types.resolve(&receiver.ty).name.to_fully_qualified(),
763 write!(out, ", ");
765 write_type(out, &arg.ty);
767 write!(out, ")");
770 write!(out, " const");
773 write!(out, " = ");
775 None => write!(out, "{}", efn.name.to_fully_qualified()),
777 out,
779 out.types.resolve(&receiver.ty).name.to_fully_qualified(),
783 writeln!(out, ";");
784 write!(out, " ");
786 out.builtin.ptr_len = true;
787 out.builtin.trycatch = true;
788 writeln!(out, "::rust::repr::PtrLen throw$;");
789 writeln!(out, " ::rust::behavior::trycatch(");
790 writeln!(out, " [&] {{");
791 write!(out, " ");
794 out.include.new = true;
795 write!(out, "new (return$) ");
796 write_indirect_return_type(out, efn.ret.as_ref().unwrap());
797 write!(out, "(");
799 write!(out, "return ");
802 Some(Type::Ref(_)) => write!(out, "&"),
804 out.builtin.rust_str_repr = true;
805 write!(out, "::rust::impl<::rust::Str>::repr(");
808 out.builtin.rust_slice_repr = true;
809 write!(out, "::rust::impl<");
810 write_type(out, ty);
811 write!(out, ">::repr(");
816 None => write!(out, "{}$(", efn.name.rust),
817 Some(_) => write!(out, "(self.*{}$)(", efn.name.rust),
821 write!(out, ", ");
824 write_type(out, &arg.ty);
825 write!(out, "::from_raw({})", arg.name.cxx);
827 write_type(out, &arg.ty);
828 write!(out, "({})", arg.name.cxx);
830 out.builtin.unsafe_bitcopy = true;
832 out,
837 out.builtin.unsafe_bitcopy = true;
838 write_type(out, &arg.ty);
839 write!(out, "(::rust::unsafe_bitcopy, *{})", arg.name.cxx);
840 } else if out.types.needs_indirect_abi(&arg.ty) {
841 out.include.utility = true;
842 write!(out, "::std::move(*{})", arg.name.cxx);
844 write!(out, "{}", arg.name.cxx);
847 write!(out, ")");
849 Some(Type::RustBox(_)) => write!(out, ".into_raw()"),
850 Some(Type::UniquePtr(_)) => write!(out, ".release()"),
851 Some(Type::Str(_)) | Some(Type::SliceRef(_)) if !indirect_return => write!(out, ")"),
855 write!(out, ")");
857 writeln!(out, ";");
859 writeln!(out, " throw$.ptr = nullptr;");
860 writeln!(out, " }},");
861 writeln!(out, " ::rust::detail::Fail(throw$));");
862 writeln!(out, " return throw$;");
864 writeln!(out, "}}");
868 write_function_pointer_trampoline(out, efn, var, f);
871 out.end_block(Block::ExternC);
874 fn write_function_pointer_trampoline(out: &mut OutFile, efn: &ExternFn, var: &Pair, f: &Signature) {
875 let r_trampoline = mangle::r_trampoline(efn, var, out.types);
877 write_rust_function_decl_impl(out, &r_trampoline, f, indirect_call);
879 out.next_section();
880 let c_trampoline = mangle::c_trampoline(efn, var, out.types).to_string();
882 write_rust_function_shim_impl(out, &c_trampoline, f, &doc, &r_trampoline, indirect_call);
885 fn write_rust_function_decl<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
886 out.set_namespace(&efn.name.namespace);
887 out.begin_block(Block::ExternC);
888 let link_name = mangle::extern_fn(efn, out.types);
890 write_rust_function_decl_impl(out, &link_name, efn, indirect_call);
891 out.end_block(Block::ExternC);
895 out: &mut OutFile,
900 out.next_section();
902 out.builtin.ptr_len = true;
903 write!(out, "::rust::repr::PtrLen ");
905 write_extern_return_type_space(out, &sig.ret);
907 write!(out, "{}(", link_name);
911 out,
913 out.types.resolve(&receiver.ty).name.to_fully_qualified(),
916 write!(out, " const");
918 write!(out, " &self");
923 write!(out, ", ");
925 write_extern_arg(out, arg);
928 if indirect_return(sig, out.types) {
930 write!(out, ", ");
934 write_type_space(out, &ret.inner);
936 write!(out, "const ");
938 write!(out, "*");
940 ret => write_type_space(out, ret),
942 write!(out, "*return$");
947 write!(out, ", ");
949 write!(out, "void *");
951 writeln!(out, ") noexcept;");
954 fn write_rust_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
955 out.set_namespace(&efn.name.namespace);
960 out.types.resolve(&receiver.ty).name.cxx,
965 let invoke = mangle::extern_fn(efn, out.types);
967 write_rust_function_shim_impl(out, &local_name, efn, doc, &invoke, indirect_call);
971 out: &mut OutFile,
976 begin_function_definition(out);
977 write_return_type(out, &sig.ret);
978 write!(out, "{}(", local_name);
981 write!(out, ", ");
983 write_type_space(out, &arg.ty);
984 write!(out, "{}", arg.name.cxx);
988 write!(out, ", ");
990 write!(out, "void *extern$");
992 write!(out, ")");
995 write!(out, " const");
999 write!(out, " noexcept");
1004 out: &mut OutFile,
1011 if out.header && sig.receiver.is_some() {
1017 write_doc(out, "", doc);
1019 write_rust_function_shim_decl(out, local_name, sig, indirect_call);
1020 if out.header {
1021 writeln!(out, ";");
1024 writeln!(out, " {{");
1026 if arg.ty != RustString && out.types.needs_indirect_abi(&arg.ty) {
1027 out.include.utility = true;
1028 out.builtin.manually_drop = true;
1029 write!(out, " ::rust::ManuallyDrop<");
1030 write_type(out, &arg.ty);
1031 writeln!(out, "> {}$(::std::move({0}));", arg.name.cxx);
1034 write!(out, " ");
1035 let indirect_return = indirect_return(sig, out.types);
1037 out.builtin.maybe_uninit = true;
1038 write!(out, "::rust::MaybeUninit<");
1041 write_type_space(out, &ret.inner);
1043 write!(out, "const ");
1045 write!(out, "*");
1047 ret => write_type(out, ret),
1049 writeln!(out, "> return$;");
1050 write!(out, " ");
1052 write!(out, "return ");
1055 write_type(out, ret);
1056 write!(out, "::from_raw(");
1059 write_type(out, ret);
1060 write!(out, "(");
1062 Type::Ref(_) => write!(out, "*"),
1064 out.builtin.rust_str_new_unchecked = true;
1065 write!(out, "::rust::impl<::rust::Str>::new_unchecked(");
1068 out.builtin.rust_slice_new = true;
1069 write!(out, "::rust::impl<");
1070 write_type(out, ret);
1071 write!(out, ">::slice(");
1077 out.builtin.ptr_len = true;
1078 write!(out, "::rust::repr::PtrLen error$ = ");
1080 write!(out, "{}(", invoke);
1083 write!(out, "*this");
1088 write!(out, ", ");
1090 if out.types.needs_indirect_abi(&arg.ty) {
1091 write!(out, "&");
1093 write!(out, "{}", arg.name.cxx);
1095 Type::RustBox(_) => write!(out, ".into_raw()"),
1096 Type::UniquePtr(_) => write!(out, ".release()"),
1097 ty if ty != RustString && out.types.needs_indirect_abi(ty) => write!(out, "$.value"),
1104 write!(out, ", ");
1106 write!(out, "&return$.value");
1111 write!(out, ", ");
1113 write!(out, "extern$");
1115 write!(out, ")");
1119 write!(out, ")");
1123 writeln!(out, ";");
1125 out.builtin.rust_error = true;
1126 writeln!(out, " if (error$.ptr) {{");
1127 writeln!(out, " throw ::rust::impl<::rust::Error>::error(error$);");
1128 writeln!(out, " }}");
1131 write!(out, " return ");
1133 Type::Ref(_) => write!(out, "*return$.value"),
1135 out.include.utility = true;
1136 write!(out, "::std::move(return$.value)");
1139 writeln!(out, ";");
1141 writeln!(out, "}}");
1144 fn write_return_type(out: &mut OutFile, ty: &Option<Type>) {
1146 None => write!(out, "void "),
1147 Some(ty) => write_type_space(out, ty),
1157 fn write_indirect_return_type(out: &mut OutFile, ty: &Type) {
1160 write_type_space(out, &ty.inner);
1161 write!(out, "*");
1164 write_type_space(out, &ty.inner);
1166 write!(out, "const ");
1168 write!(out, "*");
1170 _ => write_type(out, ty),
1174 fn write_indirect_return_type_space(out: &mut OutFile, ty: &Type) {
1175 write_indirect_return_type(out, ty);
1178 Type::Str(_) | Type::SliceRef(_) => write!(out, " "),
1179 _ => write_space_after_type(out, ty),
1183 fn write_extern_return_type_space(out: &mut OutFile, ty: &Option<Type>) {
1186 write_type_space(out, &ty.inner);
1187 write!(out, "*");
1190 write_type_space(out, &ty.inner);
1192 write!(out, "const ");
1194 write!(out, "*");
1197 out.builtin.repr_fat = true;
1198 write!(out, "::rust::repr::Fat ");
1200 Some(ty) if out.types.needs_indirect_abi(ty) => write!(out, "void "),
1201 _ => write_return_type(out, ty),
1205 fn write_extern_arg(out: &mut OutFile, arg: &Var) {
1208 write_type_space(out, &ty.inner);
1209 write!(out, "*");
1211 _ => write_type_space(out, &arg.ty),
1213 if out.types.needs_indirect_abi(&arg.ty) {
1214 write!(out, "*");
1216 write!(out, "{}", arg.name.cxx);
1219 fn write_type(out: &mut OutFile, ty: &Type) {
1222 Some(atom) => write_atom(out, atom),
1224 out,
1226 out.types.resolve(ident).name.to_fully_qualified(),
1230 write!(out, "::rust::Box<");
1231 write_type(out, &ty.inner);
1232 write!(out, ">");
1235 write!(out, "::rust::Vec<");
1236 write_type(out, &ty.inner);
1237 write!(out, ">");
1240 write!(out, "::std::unique_ptr<");
1241 write_type(out, &ptr.inner);
1242 write!(out, ">");
1245 write!(out, "::std::shared_ptr<");
1246 write_type(out, &ptr.inner);
1247 write!(out, ">");
1250 write!(out, "::std::weak_ptr<");
1251 write_type(out, &ptr.inner);
1252 write!(out, ">");
1255 write!(out, "::std::vector<");
1256 write_type(out, &ty.inner);
1257 write!(out, ">");
1260 write_type_space(out, &r.inner);
1262 write!(out, "const ");
1264 write!(out, "&");
1267 write_type_space(out, &p.inner);
1269 write!(out, "const ");
1271 write!(out, "*");
1274 write!(out, "::rust::Str");
1277 write!(out, "::rust::Slice<");
1278 write_type_space(out, &slice.inner);
1280 write!(out, "const");
1282 write!(out, ">");
1285 write!(out, "::rust::Fn<");
1287 Some(ret) => write_type(out, ret),
1288 None => write!(out, "void"),
1290 write!(out, "(");
1293 write!(out, ", ");
1295 write_type(out, &arg.ty);
1297 write!(out, ")>");
1300 write!(out, "::std::array<");
1301 write_type(out, &a.inner);
1302 write!(out, ", {}>", &a.len);
1308 fn write_atom(out: &mut OutFile, atom: Atom) {
1310 Bool => write!(out, "bool"),
1311 Char => write!(out, "char"),
1312 U8 => write!(out, "::std::uint8_t"),
1313 U16 => write!(out, "::std::uint16_t"),
1314 U32 => write!(out, "::std::uint32_t"),
1315 U64 => write!(out, "::std::uint64_t"),
1316 Usize => write!(out, "::std::size_t"),
1317 I8 => write!(out, "::std::int8_t"),
1318 I16 => write!(out, "::std::int16_t"),
1319 I32 => write!(out, "::std::int32_t"),
1320 I64 => write!(out, "::std::int64_t"),
1321 Isize => write!(out, "::rust::isize"),
1322 F32 => write!(out, "float"),
1323 F64 => write!(out, "double"),
1324 CxxString => write!(out, "::std::string"),
1325 RustString => write!(out, "::rust::String"),
1329 fn write_type_space(out: &mut OutFile, ty: &Type) {
1330 write_type(out, ty);
1331 write_space_after_type(out, ty);
1334 fn write_space_after_type(out: &mut OutFile, ty: &Type) {
1346 | Type::Array(_) => write!(out, " "),
1400 fn write_generic_instantiations(out: &mut OutFile) {
1401 if out.header {
1405 out.next_section();
1406 out.set_namespace(Default::default());
1407 out.begin_block(Block::ExternC);
1408 for impl_key in out.types.impls.keys() {
1409 out.next_section();
1411 ImplKey::RustBox(ident) => write_rust_box_extern(out, ident),
1412 ImplKey::RustVec(ident) => write_rust_vec_extern(out, ident),
1413 ImplKey::UniquePtr(ident) => write_unique_ptr(out, ident),
1414 ImplKey::SharedPtr(ident) => write_shared_ptr(out, ident),
1415 ImplKey::WeakPtr(ident) => write_weak_ptr(out, ident),
1416 ImplKey::CxxVector(ident) => write_cxx_vector(out, ident),
1419 out.end_block(Block::ExternC);
1421 out.begin_block(Block::Namespace("rust"));
1422 out.begin_block(Block::InlineNamespace("cxxbridge1"));
1423 for impl_key in out.types.impls.keys() {
1425 ImplKey::RustBox(ident) => write_rust_box_impl(out, ident),
1426 ImplKey::RustVec(ident) => write_rust_vec_impl(out, ident),
1430 out.end_block(Block::InlineNamespace("cxxbridge1"));
1431 out.end_block(Block::Namespace("rust"));
1434 fn write_rust_box_extern(out: &mut OutFile, key: NamedImplKey) {
1435 let resolve = out.types.resolve(&key);
1440 out,
1445 out,
1450 out,
1456 fn write_rust_vec_extern(out: &mut OutFile, key: NamedImplKey) {
1458 let inner = element.to_typename(out.types);
1459 let instance = element.to_mangled(out.types);
1461 out.include.cstddef = true;
1464 out,
1469 out,
1474 out,
1479 out,
1484 out,
1489 out,
1494 out,
1499 out,
1505 fn write_rust_box_impl(out: &mut OutFile, key: NamedImplKey) {
1506 let resolve = out.types.resolve(&key);
1510 writeln!(out, "template <>");
1511 begin_function_definition(out);
1513 out,
1517 writeln!(out, " return cxxbridge1$box${}$alloc();", instance);
1518 writeln!(out, "}}");
1520 writeln!(out, "template <>");
1521 begin_function_definition(out);
1523 out,
1527 writeln!(out, " cxxbridge1$box${}$dealloc(ptr);", instance);
1528 writeln!(out, "}}");
1530 writeln!(out, "template <>");
1531 begin_function_definition(out);
1532 writeln!(out, "void Box<{}>::drop() noexcept {{", inner);
1533 writeln!(out, " cxxbridge1$box${}$drop(this);", instance);
1534 writeln!(out, "}}");
1537 fn write_rust_vec_impl(out: &mut OutFile, key: NamedImplKey) {
1539 let inner = element.to_typename(out.types);
1540 let instance = element.to_mangled(out.types);
1542 out.include.cstddef = true;
1544 writeln!(out, "template <>");
1545 begin_function_definition(out);
1546 writeln!(out, "Vec<{}>::Vec() noexcept {{", inner);
1547 writeln!(out, " cxxbridge1$rust_vec${}$new(this);", instance);
1548 writeln!(out, "}}");
1550 writeln!(out, "template <>");
1551 begin_function_definition(out);
1552 writeln!(out, "void Vec<{}>::drop() noexcept {{", inner);
1553 writeln!(out, " return cxxbridge1$rust_vec${}$drop(this);", instance);
1554 writeln!(out, "}}");
1556 writeln!(out, "template <>");
1557 begin_function_definition(out);
1559 out,
1563 writeln!(out, " return cxxbridge1$rust_vec${}$len(this);", instance);
1564 writeln!(out, "}}");
1566 writeln!(out, "template <>");
1567 begin_function_definition(out);
1569 out,
1574 out,
1578 writeln!(out, "}}");
1580 writeln!(out, "template <>");
1581 begin_function_definition(out);
1582 writeln!(out, "{} const *Vec<{0}>::data() const noexcept {{", inner);
1583 writeln!(out, " return cxxbridge1$rust_vec${}$data(this);", instance);
1584 writeln!(out, "}}");
1586 writeln!(out, "template <>");
1587 begin_function_definition(out);
1589 out,
1594 out,
1598 writeln!(out, "}}");
1600 writeln!(out, "template <>");
1601 begin_function_definition(out);
1603 out,
1608 out,
1612 writeln!(out, "}}");
1614 writeln!(out, "template <>");
1615 begin_function_definition(out);
1616 writeln!(out, "void Vec<{}>::truncate(::std::size_t len) {{", inner,);
1618 out,
1622 writeln!(out, "}}");
1625 fn write_unique_ptr(out: &mut OutFile, key: NamedImplKey) {
1627 write_unique_ptr_common(out, ty);
1631 fn write_unique_ptr_common(out: &mut OutFile, ty: UniquePtr) {
1632 out.include.new = true;
1633 out.include.utility = true;
1634 let inner = ty.to_typename(out.types);
1635 let instance = ty.to_mangled(out.types);
1642 UniquePtr::Ident(ident) => out.types.is_maybe_trivial(ident),
1648 !out.types.structs.contains_key(ident) && !out.types.enums.contains_key(ident)
1654 out.builtin.is_complete = true;
1656 UniquePtr::Ident(ty) => &out.types.resolve(ty).name.cxx,
1660 out,
1666 out,
1671 out,
1675 begin_function_definition(out);
1677 out,
1681 writeln!(out, " ::new (ptr) ::std::unique_ptr<{}>();", inner);
1682 writeln!(out, "}}");
1684 out.builtin.maybe_uninit = true;
1685 begin_function_definition(out);
1687 out,
1692 out,
1696 writeln!(out, " ::new (ptr) ::std::unique_ptr<{}>(uninit);", inner);
1697 writeln!(out, " return uninit;");
1698 writeln!(out, "}}");
1700 begin_function_definition(out);
1702 out,
1706 writeln!(out, " ::new (ptr) ::std::unique_ptr<{}>(raw);", inner);
1707 writeln!(out, "}}");
1708 begin_function_definition(out);
1710 out,
1714 writeln!(out, " return ptr.get();");
1715 writeln!(out, "}}");
1716 begin_function_definition(out);
1718 out,
1722 writeln!(out, " return ptr.release();");
1723 writeln!(out, "}}");
1724 begin_function_definition(out);
1726 out,
1731 out.builtin.deleter_if = true;
1733 out,
1738 writeln!(out, " ptr->~unique_ptr();");
1740 writeln!(out, "}}");
1743 fn write_shared_ptr(out: &mut OutFile, key: NamedImplKey) {
1745 let resolve = out.types.resolve(ident);
1749 out.include.new = true;
1750 out.include.utility = true;
1756 let can_construct_from_value = out.types.is_maybe_trivial(ident);
1759 out,
1764 out,
1768 begin_function_definition(out);
1770 out,
1774 writeln!(out, " ::new (ptr) ::std::shared_ptr<{}>();", inner);
1775 writeln!(out, "}}");
1777 out.builtin.maybe_uninit = true;
1778 begin_function_definition(out);
1780 out,
1785 out,
1789 writeln!(out, " ::new (ptr) ::std::shared_ptr<{}>(uninit);", inner);
1790 writeln!(out, " return uninit;");
1791 writeln!(out, "}}");
1793 begin_function_definition(out);
1795 out,
1799 writeln!(out, " ::new (ptr) ::std::shared_ptr<{}>(self);", inner);
1800 writeln!(out, "}}");
1801 begin_function_definition(out);
1803 out,
1807 writeln!(out, " return self.get();");
1808 writeln!(out, "}}");
1809 begin_function_definition(out);
1811 out,
1815 writeln!(out, " self->~shared_ptr();");
1816 writeln!(out, "}}");
1819 fn write_weak_ptr(out: &mut OutFile, key: NamedImplKey) {
1820 let resolve = out.types.resolve(&key);
1824 out.include.new = true;
1825 out.include.utility = true;
1828 out,
1833 out,
1838 out,
1842 writeln!(out, " ::new (ptr) ::std::weak_ptr<{}>();", inner);
1843 writeln!(out, "}}");
1844 begin_function_definition(out);
1846 out,
1850 writeln!(out, " ::new (ptr) ::std::weak_ptr<{}>(self);", inner);
1851 writeln!(out, "}}");
1852 begin_function_definition(out);
1854 out,
1858 writeln!(out, " ::new (weak) ::std::weak_ptr<{}>(shared);", inner);
1859 writeln!(out, "}}");
1860 begin_function_definition(out);
1862 out,
1867 out,
1871 writeln!(out, "}}");
1872 begin_function_definition(out);
1874 out,
1878 writeln!(out, " self->~weak_ptr();");
1879 writeln!(out, "}}");
1882 fn write_cxx_vector(out: &mut OutFile, key: NamedImplKey) {
1884 let inner = element.to_typename(out.types);
1885 let instance = element.to_mangled(out.types);
1887 out.include.cstddef = true;
1888 out.include.utility = true;
1889 out.builtin.destroy = true;
1892 out,
1896 writeln!(out, " return s.size();");
1897 writeln!(out, "}}");
1899 begin_function_definition(out);
1901 out,
1905 writeln!(out, " return &(*s)[pos];");
1906 writeln!(out, "}}");
1908 if out.types.is_maybe_trivial(element) {
1909 begin_function_definition(out);
1911 out,
1915 writeln!(out, " v->push_back(::std::move(*value));");
1916 writeln!(out, " ::rust::destroy(value);");
1917 writeln!(out, "}}");
1919 begin_function_definition(out);
1921 out,
1922 "void cxxbridge1$std$vector${}$pop_back(::std::vector<{}> *v, {} *out) noexcept {{",
1925 writeln!(out, " ::new (out) {}(::std::move(v->back()));", inner);
1926 writeln!(out, " v->pop_back();");
1927 writeln!(out, "}}");
1930 out.include.memory = true;
1931 write_unique_ptr_common(out, UniquePtr::CxxVector(element));