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

cxx_gen/syntax/
check.rs
