cxx_build/syntax/
check.rs

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

cxx_build/syntax/
check.rs
