1--- 2source: macro/src/lib.rs 3expression: "rustfmt_code(&gen_bridge(parse_quote! {\n mod ffi\n {\n use\n diplomat_runtime::{\n DiplomatStr, DiplomatStr16, DiplomatByte,\n DiplomatOwnedSlice, DiplomatOwnedStr16Slice,\n DiplomatOwnedStrSlice, DiplomatOwnedUTF8StrSlice,\n DiplomatSlice, DiplomatSliceMut, DiplomatStr16Slice,\n DiplomatStrSlice, DiplomatUtf8StrSlice\n }; struct Foo<'a>\n {\n a: DiplomatSlice<'a, u8>, b: DiplomatSlice<'a, u16>, c:\n DiplomatUtf8StrSlice<'a>, d: DiplomatStrSlice<'a>, e:\n DiplomatStr16Slice<'a>, f: DiplomatSlice<'a, DiplomatByte>,\n } impl Foo\n {\n pub fn\n make(a: &'a [u8], b: &'a [u16], c: &'a str, d: &'a\n DiplomatStr, e: &'a DiplomatStr16, f: &'a [DiplomatByte]) ->\n Self { Foo { a, b, c, d, e, f, } } pub fn\n make_runtime_types(a: DiplomatSlice<'a, u8>, b:\n DiplomatSlice<'a, u16>, c: DiplomatUtf8StrSlice<'a>, d:\n DiplomatStrSlice<'a>, e: DiplomatStr16Slice<'a>, f:\n DiplomatSlice<'a, DiplomatByte>) -> Self\n {\n Foo\n {\n a: a.into(), b: b.into(), c: c.into(), d: d.into(), e:\n e.into(), f: f.into(),\n }\n } pub fn\n boxes(a: Box<[u8]>, b: Box<[u16]>, c: Box<str>, d:\n Box<DiplomatStr>, e: Box<DiplomatStr16>, f:\n Box<[DiplomatByte]>) -> Self { unimplemented!() } pub fn\n boxes_runtime_types(a: DiplomatOwnedSlice<u8>, b:\n DiplomatOwnedSlice<u16>, c: DiplomatOwnedUTF8StrSlice, d:\n DiplomatOwnedStrSlice, e: DiplomatOwnedStr16Slice, f:\n DiplomatOwnedSlice<DiplomatByte>) -> Self\n { unimplemented!() } pub fn a(self) -> &[u8] { self.a } pub\n fn b(self) -> &[u16] { self.b } pub fn c(self) -> &str\n { self.c } pub fn d(self) -> &DiplomatStr { self.d } pub fn\n e(self) -> &DiplomatStr16 { self.e } pub fn f(self) ->\n &[DiplomatByte] { self.f }\n }\n }\n }).to_token_stream().to_string())" 4--- 5mod ffi { 6 use diplomat_runtime::{ 7 DiplomatByte, DiplomatOwnedSlice, DiplomatOwnedStr16Slice, DiplomatOwnedStrSlice, 8 DiplomatOwnedUTF8StrSlice, DiplomatSlice, DiplomatSliceMut, DiplomatStr, DiplomatStr16, 9 DiplomatStr16Slice, DiplomatStrSlice, DiplomatUtf8StrSlice, 10 }; 11 #[repr(C)] 12 struct Foo<'a> { 13 a: DiplomatSlice<'a, u8>, 14 b: DiplomatSlice<'a, u16>, 15 c: DiplomatUtf8StrSlice<'a>, 16 d: DiplomatStrSlice<'a>, 17 e: DiplomatStr16Slice<'a>, 18 f: DiplomatSlice<'a, DiplomatByte>, 19 } 20 impl Foo { 21 pub fn make( 22 a: &'a [u8], 23 b: &'a [u16], 24 c: &'a str, 25 d: &'a DiplomatStr, 26 e: &'a DiplomatStr16, 27 f: &'a [DiplomatByte], 28 ) -> Self { 29 Foo { a, b, c, d, e, f } 30 } 31 pub fn make_runtime_types( 32 a: DiplomatSlice<'a, u8>, 33 b: DiplomatSlice<'a, u16>, 34 c: DiplomatUtf8StrSlice<'a>, 35 d: DiplomatStrSlice<'a>, 36 e: DiplomatStr16Slice<'a>, 37 f: DiplomatSlice<'a, DiplomatByte>, 38 ) -> Self { 39 Foo { 40 a: a.into(), 41 b: b.into(), 42 c: c.into(), 43 d: d.into(), 44 e: e.into(), 45 f: f.into(), 46 } 47 } 48 pub fn boxes( 49 a: Box<[u8]>, 50 b: Box<[u16]>, 51 c: Box<str>, 52 d: Box<DiplomatStr>, 53 e: Box<DiplomatStr16>, 54 f: Box<[DiplomatByte]>, 55 ) -> Self { 56 unimplemented!() 57 } 58 pub fn boxes_runtime_types( 59 a: DiplomatOwnedSlice<u8>, 60 b: DiplomatOwnedSlice<u16>, 61 c: DiplomatOwnedUTF8StrSlice, 62 d: DiplomatOwnedStrSlice, 63 e: DiplomatOwnedStr16Slice, 64 f: DiplomatOwnedSlice<DiplomatByte>, 65 ) -> Self { 66 unimplemented!() 67 } 68 pub fn a(self) -> &[u8] { 69 self.a 70 } 71 pub fn b(self) -> &[u16] { 72 self.b 73 } 74 pub fn c(self) -> &str { 75 self.c 76 } 77 pub fn d(self) -> &DiplomatStr { 78 self.d 79 } 80 pub fn e(self) -> &DiplomatStr16 { 81 self.e 82 } 83 pub fn f(self) -> &[DiplomatByte] { 84 self.f 85 } 86 } 87 use core::ffi::c_void; 88 use diplomat_runtime::*; 89 #[no_mangle] 90 extern "C" fn Foo_make( 91 a: diplomat_runtime::DiplomatSlice<'a, u8>, 92 b: diplomat_runtime::DiplomatSlice<'a, u16>, 93 c: diplomat_runtime::DiplomatUtf8StrSlice<'a>, 94 d: diplomat_runtime::DiplomatStrSlice<'a>, 95 e: diplomat_runtime::DiplomatStr16Slice<'a>, 96 f: diplomat_runtime::DiplomatSlice<'a, DiplomatByte>, 97 ) -> Foo { 98 let a = a.into(); 99 let b = b.into(); 100 let c = c.into(); 101 let d = d.into(); 102 let e = e.into(); 103 let f = f.into(); 104 Foo::make(a, b, c, d, e, f) 105 } 106 #[no_mangle] 107 extern "C" fn Foo_make_runtime_types( 108 a: diplomat_runtime::DiplomatOwnedSlice<u8>, 109 b: diplomat_runtime::DiplomatOwnedSlice<u16>, 110 c: diplomat_runtime::DiplomatUtf8StrSlice<'a>, 111 d: diplomat_runtime::DiplomatStrSlice<'a>, 112 e: diplomat_runtime::DiplomatStr16Slice<'a>, 113 f: diplomat_runtime::DiplomatOwnedSlice<DiplomatByte>, 114 ) -> Foo { 115 Foo::make_runtime_types(a, b, c, d, e, f) 116 } 117 #[no_mangle] 118 extern "C" fn Foo_boxes( 119 a: diplomat_runtime::DiplomatOwnedSlice<u8>, 120 b: diplomat_runtime::DiplomatOwnedSlice<u16>, 121 c: diplomat_runtime::DiplomatOwnedUTF8StrSlice, 122 d: diplomat_runtime::DiplomatOwnedStrSlice, 123 e: diplomat_runtime::DiplomatOwnedStr16Slice, 124 f: diplomat_runtime::DiplomatOwnedSlice<DiplomatByte>, 125 ) -> Foo { 126 let a = a.into(); 127 let b = b.into(); 128 let c = c.into(); 129 let d = d.into(); 130 let e = e.into(); 131 let f = f.into(); 132 Foo::boxes(a, b, c, d, e, f) 133 } 134 #[no_mangle] 135 extern "C" fn Foo_boxes_runtime_types( 136 a: diplomat_runtime::DiplomatSliceMut<u8>, 137 b: diplomat_runtime::DiplomatSliceMut<u16>, 138 c: diplomat_runtime::DiplomatOwnedUTF8StrSlice, 139 d: diplomat_runtime::DiplomatOwnedStrSlice, 140 e: diplomat_runtime::DiplomatOwnedStr16Slice, 141 f: diplomat_runtime::DiplomatSliceMut<DiplomatByte>, 142 ) -> Foo { 143 Foo::boxes_runtime_types(a, b, c, d, e, f) 144 } 145 #[no_mangle] 146 extern "C" fn Foo_a(this: Foo) -> diplomat_runtime::DiplomatSlice<u8> { 147 this.a().into() 148 } 149 #[no_mangle] 150 extern "C" fn Foo_b(this: Foo) -> diplomat_runtime::DiplomatSlice<u16> { 151 this.b().into() 152 } 153 #[no_mangle] 154 extern "C" fn Foo_c(this: Foo) -> diplomat_runtime::DiplomatUtf8StrSlice { 155 this.c().into() 156 } 157 #[no_mangle] 158 extern "C" fn Foo_d(this: Foo) -> diplomat_runtime::DiplomatStrSlice { 159 this.d().into() 160 } 161 #[no_mangle] 162 extern "C" fn Foo_e(this: Foo) -> diplomat_runtime::DiplomatStr16Slice { 163 this.e().into() 164 } 165 #[no_mangle] 166 extern "C" fn Foo_f(this: Foo) -> diplomat_runtime::DiplomatSlice<DiplomatByte> { 167 this.f().into() 168 } 169} 170