cxx_gen/syntax/
check.rs

1use crate::syntax::atom::Atom::{self, *};
2use crate::syntax::message::Message;
3use crate::syntax::report::Errors;
4use crate::syntax::visit::{self, Visit};
5use crate::syntax::{
6    error, ident, trivial, Api, Array, Enum, ExternFn, ExternType, FnKind, Impl, Lang, Lifetimes,
7    NamedType, Ptr, Receiver, Ref, Signature, SliceRef, Struct, Trait, Ty1, Type, TypeAlias, Types,
8};
9use proc_macro2::{Delimiter, Group, Ident, TokenStream};
10use quote::{quote, ToTokens};
11use std::fmt::Display;
12use syn::{GenericParam, Generics, Lifetime};
13
14pub(crate) struct Check<'a> {
15    apis: &'a [Api],
16    types: &'a Types<'a>,
17    errors: &'a mut Errors,
18    generator: Generator,
19}
20
21pub(crate) enum Generator {
22    // cxx-build crate, cxxbridge cli, cxx-gen.
23    #[cfg_attr(proc_macro, expect(dead_code))]
24    Build,
25    // cxxbridge-macro. This is relevant in that the macro output is going to
26    // get fed straight to rustc, so for errors that rustc already contains
27    // logic to catch (probably with a better diagnostic than what the proc
28    // macro API is able to produce), we avoid duplicating them in our own
29    // diagnostics.
30    #[cfg_attr(not(proc_macro), expect(dead_code))]
31    Macro,
32}
33
34pub(crate) fn typecheck(cx: &mut Errors, apis: &[Api], types: &Types, generator: Generator) {
35    do_typecheck(&mut Check {
36        apis,
37        types,
38        errors: cx,
39        generator,
40    });
41}
42
43fn do_typecheck(cx: &mut Check) {
44    ident::check_all(cx, cx.apis);
45
46    for ty in cx.types {
47        match ty {
48            Type::Ident(ident) => check_type_ident(cx, ident),
49            Type::RustBox(ptr) => check_type_box(cx, ptr),
50            Type::RustVec(ty) => check_type_rust_vec(cx, ty),
51            Type::UniquePtr(ptr) => check_type_unique_ptr(cx, ptr),
52            Type::SharedPtr(ptr) => check_type_shared_ptr(cx, ptr),
53            Type::WeakPtr(ptr) => check_type_weak_ptr(cx, ptr),
54            Type::CxxVector(ptr) => check_type_cxx_vector(cx, ptr),
55            Type::Ref(ty) => check_type_ref(cx, ty),
56            Type::Ptr(ty) => check_type_ptr(cx, ty),
57            Type::Array(array) => check_type_array(cx, array),
58            Type::Fn(ty) => check_type_fn(cx, ty),
59            Type::SliceRef(ty) => check_type_slice_ref(cx, ty),
60            Type::Str(_) | Type::Void(_) => {}
61        }
62    }
63
64    for api in cx.apis {
65        match api {
66            Api::Include(_) => {}
67            Api::Struct(strct) => check_api_struct(cx, strct),
68            Api::Enum(enm) => check_api_enum(cx, enm),
69            Api::CxxType(ety) | Api::RustType(ety) => check_api_type(cx, ety),
70            Api::CxxFunction(efn) | Api::RustFunction(efn) => check_api_fn(cx, efn),
71            Api::TypeAlias(alias) => check_api_type_alias(cx, alias),
72            Api::Impl(imp) => check_api_impl(cx, imp),
73        }
74    }
75}
76
77impl Check<'_> {
78    pub(crate) fn error(&mut self, sp: impl ToTokens, msg: impl Display) {
79        self.errors.error(sp, msg);
80    }
81}
82
83fn check_type_ident(cx: &mut Check, name: &NamedType) {
84    let ident = &name.rust;
85    if Atom::from(ident).is_none()
86        && !cx.types.structs.contains_key(ident)
87        && !cx.types.enums.contains_key(ident)
88        && !cx.types.cxx.contains(ident)
89        && !cx.types.rust.contains(ident)
90    {
91        let msg = format!("unsupported type: {}", ident);
92        cx.error(ident, msg);
93    }
94}
95
96fn check_type_box(cx: &mut Check, ptr: &Ty1) {
97    if let Type::Ident(ident) = &ptr.inner {
98        if cx.types.cxx.contains(&ident.rust)
99            && !cx.types.aliases.contains_key(&ident.rust)
100            && !cx.types.structs.contains_key(&ident.rust)
101            && !cx.types.enums.contains_key(&ident.rust)
102        {
103            cx.error(ptr, error::BOX_CXX_TYPE.msg);
104        }
105
106        if Atom::from(&ident.rust).is_none() {
107            return;
108        }
109    }
110
111    cx.error(ptr, "unsupported target type of Box");
112}
113
114fn check_type_rust_vec(cx: &mut Check, ty: &Ty1) {
115    match &ty.inner {
116        Type::Ident(ident) => {
117            if cx.types.cxx.contains(&ident.rust)
118                && !cx.types.aliases.contains_key(&ident.rust)
119                && !cx.types.structs.contains_key(&ident.rust)
120                && !cx.types.enums.contains_key(&ident.rust)
121            {
122                cx.error(ty, "Rust Vec containing C++ type is not supported yet");
123                return;
124            }
125
126            match Atom::from(&ident.rust) {
127                None
128                | Some(
129                    Bool | Char | U8 | U16 | U32 | U64 | Usize | I8 | I16 | I32 | I64 | Isize | F32
130                    | F64 | RustString,
131                ) => return,
132                Some(CxxString) => {}
133            }
134        }
135        Type::Str(_) => return,
136        _ => {}
137    }
138
139    cx.error(ty, "unsupported element type of Vec");
140}
141
142fn check_type_unique_ptr(cx: &mut Check, ptr: &Ty1) {
143    if let Type::Ident(ident) = &ptr.inner {
144        if cx.types.rust.contains(&ident.rust) {
145            cx.error(ptr, "unique_ptr of a Rust type is not supported yet");
146            return;
147        }
148
149        match Atom::from(&ident.rust) {
150            None | Some(CxxString) => return,
151            _ => {}
152        }
153    } else if let Type::CxxVector(_) = &ptr.inner {
154        return;
155    }
156
157    cx.error(ptr, "unsupported unique_ptr target type");
158}
159
160fn check_type_shared_ptr(cx: &mut Check, ptr: &Ty1) {
161    if let Type::Ident(ident) = &ptr.inner {
162        if cx.types.rust.contains(&ident.rust) {
163            cx.error(ptr, "shared_ptr of a Rust type is not supported yet");
164            return;
165        }
166
167        match Atom::from(&ident.rust) {
168            None
169            | Some(
170                Bool | U8 | U16 | U32 | U64 | Usize | I8 | I16 | I32 | I64 | Isize | F32 | F64
171                | CxxString,
172            ) => return,
173            Some(Char | RustString) => {}
174        }
175    } else if let Type::CxxVector(_) = &ptr.inner {
176        cx.error(ptr, "std::shared_ptr<std::vector> is not supported yet");
177        return;
178    }
179
180    cx.error(ptr, "unsupported shared_ptr target type");
181}
182
183fn check_type_weak_ptr(cx: &mut Check, ptr: &Ty1) {
184    if let Type::Ident(ident) = &ptr.inner {
185        if cx.types.rust.contains(&ident.rust) {
186            cx.error(ptr, "weak_ptr of a Rust type is not supported yet");
187            return;
188        }
189
190        match Atom::from(&ident.rust) {
191            None
192            | Some(
193                Bool | U8 | U16 | U32 | U64 | Usize | I8 | I16 | I32 | I64 | Isize | F32 | F64
194                | CxxString,
195            ) => return,
196            Some(Char | RustString) => {}
197        }
198    } else if let Type::CxxVector(_) = &ptr.inner {
199        cx.error(ptr, "std::weak_ptr<std::vector> is not supported yet");
200        return;
201    }
202
203    cx.error(ptr, "unsupported weak_ptr target type");
204}
205
206fn check_type_cxx_vector(cx: &mut Check, ptr: &Ty1) {
207    if let Type::Ident(ident) = &ptr.inner {
208        if cx.types.rust.contains(&ident.rust) {
209            cx.error(
210                ptr,
211                "C++ vector containing a Rust type is not supported yet",
212            );
213            return;
214        }
215
216        match Atom::from(&ident.rust) {
217            None
218            | Some(
219                U8 | U16 | U32 | U64 | Usize | I8 | I16 | I32 | I64 | Isize | F32 | F64 | CxxString,
220            ) => return,
221            Some(Char) => { /* todo */ }
222            Some(Bool | RustString) => {}
223        }
224    }
225
226    cx.error(ptr, "unsupported vector element type");
227}
228
229fn check_type_ref(cx: &mut Check, ty: &Ref) {
230    if ty.mutable && !ty.pinned {
231        if let Some(requires_pin) = match &ty.inner {
232            Type::Ident(ident)
233                if ident.rust == CxxString
234                    || (cx.types.cxx.contains(&ident.rust)
235                        && !cx.types.structs.contains_key(&ident.rust)
236                        && !cx.types.enums.contains_key(&ident.rust)
237                        && !cx.types.aliases.contains_key(&ident.rust)) =>
238            {
239                Some(ident.rust.to_string())
240            }
241            Type::CxxVector(_) => Some("CxxVector<...>".to_owned()),
242            _ => None,
243        } {
244            cx.error(
245                ty,
246                format!(
247                    "mutable reference to C++ type requires a pin -- use Pin<&mut {}>",
248                    requires_pin,
249                ),
250            );
251        }
252    }
253
254    match ty.inner {
255        Type::Fn(_) | Type::Void(_) => {}
256        Type::Ref(_) => {
257            cx.error(ty, "C++ does not allow references to references");
258            return;
259        }
260        _ => return,
261    }
262
263    cx.error(ty, "unsupported reference type");
264}
265
266fn check_type_ptr(cx: &mut Check, ty: &Ptr) {
267    match ty.inner {
268        Type::Fn(_) | Type::Void(_) => {}
269        Type::Ref(_) => {
270            cx.error(ty, "C++ does not allow pointer to reference as a type");
271            return;
272        }
273        _ => return,
274    }
275
276    cx.error(ty, "unsupported pointer type");
277}
278
279fn check_type_slice_ref(cx: &mut Check, ty: &SliceRef) {
280    let supported = !is_unsized(cx.types, &ty.inner)
281        || match &ty.inner {
282            Type::Ident(ident) => {
283                cx.types.rust.contains(&ident.rust) || cx.types.aliases.contains_key(&ident.rust)
284            }
285            _ => false,
286        };
287
288    if !supported {
289        let mutable = if ty.mutable { "mut " } else { "" };
290        let mut msg = format!("unsupported &{}[T] element type", mutable);
291        if let Type::Ident(ident) = &ty.inner {
292            if cx.types.cxx.contains(&ident.rust)
293                && !cx.types.structs.contains_key(&ident.rust)
294                && !cx.types.enums.contains_key(&ident.rust)
295            {
296                msg += ": opaque C++ type is not supported yet";
297            }
298        }
299        cx.error(ty, msg);
300    }
301}
302
303fn check_type_array(cx: &mut Check, ty: &Array) {
304    let supported = !is_unsized(cx.types, &ty.inner);
305
306    if !supported {
307        cx.error(ty, "unsupported array element type");
308    }
309}
310
311fn check_type_fn(cx: &mut Check, ty: &Signature) {
312    if ty.throws {
313        cx.error(ty, "function pointer returning Result is not supported yet");
314    }
315
316    for arg in &ty.args {
317        if let Type::Ptr(_) = arg.ty {
318            if ty.unsafety.is_none() {
319                cx.error(
320                    arg,
321                    "pointer argument requires that the function pointer be marked unsafe",
322                );
323            }
324        }
325    }
326}
327
328fn check_api_struct(cx: &mut Check, strct: &Struct) {
329    let name = &strct.name;
330    check_reserved_name(cx, &name.rust);
331    check_lifetimes(cx, &strct.generics);
332
333    if strct.fields.is_empty() {
334        let span = span_for_struct_error(strct);
335        cx.error(span, "structs without any fields are not supported");
336    }
337
338    if cx.types.cxx.contains(&name.rust) {
339        if let Some(ety) = cx.types.untrusted.get(&name.rust) {
340            let msg = "extern shared struct must be declared in an `unsafe extern` block";
341            cx.error(ety, msg);
342        }
343    }
344
345    for derive in &strct.derives {
346        if derive.what == Trait::ExternType {
347            let msg = format!("derive({}) on shared struct is not supported", derive);
348            cx.error(derive, msg);
349        }
350    }
351
352    for field in &strct.fields {
353        if let Type::Fn(_) = field.ty {
354            cx.error(
355                field,
356                "function pointers in a struct field are not implemented yet",
357            );
358        } else if is_unsized(cx.types, &field.ty) {
359            let desc = describe(cx.types, &field.ty);
360            let msg = format!("using {} by value is not supported", desc);
361            cx.error(field, msg);
362        }
363    }
364}
365
366fn check_api_enum(cx: &mut Check, enm: &Enum) {
367    check_reserved_name(cx, &enm.name.rust);
368    check_lifetimes(cx, &enm.generics);
369
370    if enm.variants.is_empty() && !enm.explicit_repr {
371        let span = span_for_enum_error(enm);
372        cx.error(
373            span,
374            "explicit #[repr(...)] is required for enum without any variants",
375        );
376    }
377
378    for derive in &enm.derives {
379        if derive.what == Trait::Default {
380            let default_variants = enm.variants.iter().filter(|v| v.default).count();
381            if default_variants != 1 {
382                let mut msg = Message::new();
383                write!(msg, "derive(Default) on enum requires exactly one variant to be marked with #[default]");
384                if default_variants > 0 {
385                    write!(msg, " (found {})", default_variants);
386                }
387                cx.error(derive, msg);
388            }
389        } else if derive.what == Trait::ExternType {
390            let msg = "derive(ExternType) on shared enum is not supported";
391            cx.error(derive, msg);
392        }
393    }
394}
395
396fn check_api_type(cx: &mut Check, ety: &ExternType) {
397    check_reserved_name(cx, &ety.name.rust);
398    check_lifetimes(cx, &ety.generics);
399
400    for derive in &ety.derives {
401        if derive.what == Trait::ExternType && ety.lang == Lang::Rust {
402            continue;
403        }
404        let lang = match ety.lang {
405            Lang::Rust => "Rust",
406            Lang::Cxx | Lang::CxxUnwind => "C++",
407        };
408        let msg = format!(
409            "derive({}) on opaque {} type is not supported yet",
410            derive, lang,
411        );
412        cx.error(derive, msg);
413    }
414
415    if !ety.bounds.is_empty() {
416        let bounds = &ety.bounds;
417        let span = quote!(#(#bounds)*);
418        cx.error(span, "extern type bounds are not implemented yet");
419    }
420
421    if let Some(reasons) = cx.types.required_trivial.get(&ety.name.rust) {
422        let msg = format!(
423            "needs a cxx::ExternType impl in order to be used as {}",
424            trivial::as_what(&ety.name, reasons),
425        );
426        cx.error(ety, msg);
427    }
428}
429
430fn check_api_fn(cx: &mut Check, efn: &ExternFn) {
431    match efn.lang {
432        Lang::Cxx | Lang::CxxUnwind => {
433            if !efn.generics.params.is_empty() && !efn.trusted {
434                let ref span = span_for_generics_error(efn);
435                cx.error(span, "extern C++ function with lifetimes must be declared in `unsafe extern \"C++\"` block");
436            }
437        }
438        Lang::Rust => {
439            if !efn.generics.params.is_empty() && efn.unsafety.is_none() {
440                let ref span = span_for_generics_error(efn);
441                let message = format!(
442                    "must be `unsafe fn {}` in order to expose explicit lifetimes to C++",
443                    efn.name.rust,
444                );
445                cx.error(span, message);
446            }
447        }
448    }
449
450    check_generics(cx, &efn.generics);
451
452    match &efn.kind {
453        FnKind::Method(receiver) => {
454            let ref span = span_for_receiver_error(receiver);
455
456            if receiver.ty.rust == "Self" {
457                let mutability = match receiver.mutable {
458                    true => "mut ",
459                    false => "",
460                };
461                let msg = format!(
462                    "unnamed receiver type is only allowed if the surrounding extern block contains exactly one extern type; use `self: &{mutability}TheType`",
463                    mutability = mutability,
464                );
465                cx.error(span, msg);
466            } else if cx.types.enums.contains_key(&receiver.ty.rust) {
467                cx.error(
468                    span,
469                    "unsupported receiver type; C++ does not allow member functions on enums",
470                );
471            } else if !cx.types.structs.contains_key(&receiver.ty.rust)
472                && !cx.types.cxx.contains(&receiver.ty.rust)
473                && !cx.types.rust.contains(&receiver.ty.rust)
474            {
475                cx.error(span, "unrecognized receiver type");
476            } else if receiver.mutable
477                && !receiver.pinned
478                && cx.types.cxx.contains(&receiver.ty.rust)
479                && !cx.types.structs.contains_key(&receiver.ty.rust)
480                && !cx.types.aliases.contains_key(&receiver.ty.rust)
481            {
482                cx.error(
483                    span,
484                    format!(
485                        "mutable reference to opaque C++ type requires a pin -- use `self: Pin<&mut {}>`",
486                        receiver.ty.rust,
487                    ),
488                );
489            }
490        }
491        FnKind::Assoc(self_type) => {
492            if cx.types.enums.contains_key(self_type) {
493                cx.error(
494                    self_type,
495                    "unsupported self type; C++ does not allow member functions on enums",
496                );
497            } else if !cx.types.structs.contains_key(self_type)
498                && !cx.types.cxx.contains(self_type)
499                && !cx.types.rust.contains(self_type)
500            {
501                cx.error(self_type, "unrecognized self type");
502            }
503        }
504        FnKind::Free => {}
505    }
506
507    for arg in &efn.args {
508        if let Type::Fn(_) = arg.ty {
509            if efn.lang == Lang::Rust {
510                cx.error(
511                    arg,
512                    "passing a function pointer from C++ to Rust is not implemented yet",
513                );
514            }
515        } else if let Type::Ptr(_) = arg.ty {
516            if efn.unsafety.is_none() {
517                cx.error(
518                    arg,
519                    "pointer argument requires that the function be marked unsafe",
520                );
521            }
522        } else if is_unsized(cx.types, &arg.ty) {
523            let desc = describe(cx.types, &arg.ty);
524            let msg = format!("passing {} by value is not supported", desc);
525            cx.error(arg, msg);
526        }
527    }
528
529    if let Some(ty) = &efn.ret {
530        if let Type::Fn(_) = ty {
531            cx.error(ty, "returning a function pointer is not implemented yet");
532        } else if is_unsized(cx.types, ty) {
533            let desc = describe(cx.types, ty);
534            let msg = format!("returning {} by value is not supported", desc);
535            cx.error(ty, msg);
536        }
537    }
538
539    if efn.lang == Lang::Cxx {
540        check_mut_return_restriction(cx, efn);
541    }
542}
543
544fn check_api_type_alias(cx: &mut Check, alias: &TypeAlias) {
545    check_lifetimes(cx, &alias.generics);
546
547    for derive in &alias.derives {
548        let msg = format!("derive({}) on extern type alias is not supported", derive);
549        cx.error(derive, msg);
550    }
551}
552
553fn check_api_impl(cx: &mut Check, imp: &Impl) {
554    let ty = &imp.ty;
555
556    check_lifetimes(cx, &imp.impl_generics);
557
558    if let Some(negative) = imp.negative_token {
559        let span = quote!(#negative #ty);
560        cx.error(span, "negative impl is not supported yet");
561        return;
562    }
563
564    match ty {
565        Type::RustBox(ty)
566        | Type::RustVec(ty)
567        | Type::UniquePtr(ty)
568        | Type::SharedPtr(ty)
569        | Type::WeakPtr(ty)
570        | Type::CxxVector(ty) => {
571            if let Type::Ident(inner) = &ty.inner {
572                if Atom::from(&inner.rust).is_none() {
573                    return;
574                }
575            }
576        }
577        _ => {}
578    }
579
580    cx.error(imp, "unsupported Self type of explicit impl");
581}
582
583fn check_mut_return_restriction(cx: &mut Check, efn: &ExternFn) {
584    if efn.unsafety.is_some() {
585        // Unrestricted as long as the function is made unsafe-to-call.
586        return;
587    }
588
589    match &efn.ret {
590        Some(Type::Ref(ty)) if ty.mutable => {}
591        Some(Type::SliceRef(slice)) if slice.mutable => {}
592        _ => return,
593    }
594
595    if let Some(receiver) = efn.receiver() {
596        if receiver.mutable {
597            return;
598        }
599        let Some(resolve) = cx.types.try_resolve(&receiver.ty) else {
600            return;
601        };
602        if !resolve.generics.lifetimes.is_empty() {
603            return;
604        }
605    }
606
607    struct FindLifetimeMut<'a> {
608        cx: &'a Check<'a>,
609        found: bool,
610    }
611
612    impl<'t, 'a> Visit<'t> for FindLifetimeMut<'a> {
613        fn visit_type(&mut self, ty: &'t Type) {
614            self.found |= match ty {
615                Type::Ref(ty) => ty.mutable,
616                Type::SliceRef(slice) => slice.mutable,
617                Type::Ident(ident) if Atom::from(&ident.rust).is_none() => {
618                    match self.cx.types.try_resolve(ident) {
619                        Some(resolve) => !resolve.generics.lifetimes.is_empty(),
620                        None => true,
621                    }
622                }
623                _ => false,
624            };
625            visit::visit_type(self, ty);
626        }
627    }
628
629    let mut visitor = FindLifetimeMut { cx, found: false };
630
631    for arg in &efn.args {
632        visitor.visit_type(&arg.ty);
633    }
634
635    if visitor.found {
636        return;
637    }
638
639    cx.error(
640        efn,
641        "&mut return type is not allowed unless there is a &mut argument",
642    );
643}
644
645fn check_reserved_name(cx: &mut Check, ident: &Ident) {
646    if ident == "Box"
647        || ident == "UniquePtr"
648        || ident == "SharedPtr"
649        || ident == "WeakPtr"
650        || ident == "Vec"
651        || ident == "CxxVector"
652        || ident == "str"
653        || Atom::from(ident).is_some()
654    {
655        cx.error(ident, "reserved name");
656    }
657}
658
659fn check_reserved_lifetime(cx: &mut Check, lifetime: &Lifetime) {
660    if lifetime.ident == "static" {
661        match cx.generator {
662            Generator::Macro => { /* rustc already reports this */ }
663            Generator::Build => {
664                cx.error(lifetime, error::RESERVED_LIFETIME);
665            }
666        }
667    }
668}
669
670fn check_lifetimes(cx: &mut Check, generics: &Lifetimes) {
671    for lifetime in &generics.lifetimes {
672        check_reserved_lifetime(cx, lifetime);
673    }
674}
675
676fn check_generics(cx: &mut Check, generics: &Generics) {
677    for generic_param in &generics.params {
678        if let GenericParam::Lifetime(def) = generic_param {
679            check_reserved_lifetime(cx, &def.lifetime);
680        }
681    }
682}
683
684fn is_unsized(types: &Types, ty: &Type) -> bool {
685    match ty {
686        Type::Ident(ident) => {
687            let ident = &ident.rust;
688            ident == CxxString
689                || (types.cxx.contains(ident)
690                    && !types.structs.contains_key(ident)
691                    && !types.enums.contains_key(ident)
692                    && !(types.aliases.contains_key(ident)
693                        && types.required_trivial.contains_key(ident)))
694                || types.rust.contains(ident)
695        }
696        Type::Array(array) => is_unsized(types, &array.inner),
697        Type::CxxVector(_) | Type::Fn(_) | Type::Void(_) => true,
698        Type::RustBox(_)
699        | Type::RustVec(_)
700        | Type::UniquePtr(_)
701        | Type::SharedPtr(_)
702        | Type::WeakPtr(_)
703        | Type::Ref(_)
704        | Type::Ptr(_)
705        | Type::Str(_)
706        | Type::SliceRef(_) => false,
707    }
708}
709
710fn span_for_struct_error(strct: &Struct) -> TokenStream {
711    let struct_token = strct.struct_token;
712    let mut brace_token = Group::new(Delimiter::Brace, TokenStream::new());
713    brace_token.set_span(strct.brace_token.span.join());
714    quote!(#struct_token #brace_token)
715}
716
717fn span_for_enum_error(enm: &Enum) -> TokenStream {
718    let enum_token = enm.enum_token;
719    let mut brace_token = Group::new(Delimiter::Brace, TokenStream::new());
720    brace_token.set_span(enm.brace_token.span.join());
721    quote!(#enum_token #brace_token)
722}
723
724fn span_for_receiver_error(receiver: &Receiver) -> TokenStream {
725    let ampersand = receiver.ampersand;
726    let lifetime = &receiver.lifetime;
727    let mutability = receiver.mutability;
728    if receiver.shorthand {
729        let var = receiver.var;
730        quote!(#ampersand #lifetime #mutability #var)
731    } else {
732        let ty = &receiver.ty;
733        quote!(#ampersand #lifetime #mutability #ty)
734    }
735}
736
737fn span_for_generics_error(efn: &ExternFn) -> TokenStream {
738    let unsafety = efn.unsafety;
739    let fn_token = efn.fn_token;
740    let generics = &efn.generics;
741    quote!(#unsafety #fn_token #generics)
742}
743
744fn describe(types: &Types, ty: &Type) -> String {
745    match ty {
746        Type::Ident(ident) => {
747            if types.structs.contains_key(&ident.rust) {
748                "struct".to_owned()
749            } else if types.enums.contains_key(&ident.rust) {
750                "enum".to_owned()
751            } else if types.aliases.contains_key(&ident.rust) {
752                "C++ type".to_owned()
753            } else if types.cxx.contains(&ident.rust) {
754                "opaque C++ type".to_owned()
755            } else if types.rust.contains(&ident.rust) {
756                "opaque Rust type".to_owned()
757            } else if Atom::from(&ident.rust) == Some(CxxString) {
758                "C++ string".to_owned()
759            } else if Atom::from(&ident.rust) == Some(Char) {
760                "C char".to_owned()
761            } else {
762                ident.rust.to_string()
763            }
764        }
765        Type::RustBox(_) => "Box".to_owned(),
766        Type::RustVec(_) => "Vec".to_owned(),
767        Type::UniquePtr(_) => "unique_ptr".to_owned(),
768        Type::SharedPtr(_) => "shared_ptr".to_owned(),
769        Type::WeakPtr(_) => "weak_ptr".to_owned(),
770        Type::Ref(_) => "reference".to_owned(),
771        Type::Ptr(_) => "raw pointer".to_owned(),
772        Type::Str(_) => "&str".to_owned(),
773        Type::CxxVector(_) => "C++ vector".to_owned(),
774        Type::SliceRef(_) => "slice".to_owned(),
775        Type::Fn(_) => "function pointer".to_owned(),
776        Type::Void(_) => "()".to_owned(),
777        Type::Array(_) => "array".to_owned(),
778    }
779}
cxx_gen/syntax/check.rs

cxx_gen/syntax/
check.rs
