Add CxxExceptionPtr atom

This represents C++ `std::exception_ptr` on the Rust side via
`CxxException` object, which can be mentioned as a return type for
functions creating custom exceptions or evaluating exceptions caught
from C++ (added in further commits).

Author: schreter

gen/src/write.rs

@@ -211,7 +211,7 @@ fn pick_includes_and_builtins(out: &mut OutFile, apis: &[Api]) {
                 Some(Isize) => out.builtin.rust_isize = true,
                 Some(CxxString) => out.include.string = true,
                 Some(RustString) => out.builtin.rust_string = true,
-                Some(Bool) | Some(Char) | Some(F32) | Some(F64) | None => {}
+                Some(Bool) | Some(Char) | Some(F32) | Some(F64) | Some(CxxExceptionPtr) | None => {}
             },
             Type::RustBox(_) => out.builtin.rust_box = true,
             Type::RustVec(_) => out.builtin.rust_vec = true,
@@ -1323,6 +1323,7 @@ fn write_atom(out: &mut OutFile, atom: Atom) {
         F64 => write!(out, "double"),
         CxxString => write!(out, "::std::string"),
         RustString => write!(out, "::rust::String"),
+        CxxExceptionPtr => write!(out, "::std::exception_ptr"),
     }
 }
 

macro/src/expand.rs

@@ -1751,6 +1751,10 @@ fn expand_extern_type(ty: &Type, types: &Types, proper: bool) -> TokenStream {
             let span = ident.rust.span();
             quote_spanned!(span=> ::cxx::private::RustString)
         }
+        Type::Ident(ident) if ident.rust == CxxExceptionPtr => {
+            let span = ident.rust.span();
+            quote_spanned!(span=> ::cxx::CxxException)
+        }
         Type::RustBox(ty) | Type::UniquePtr(ty) => {
             let span = ty.name.span();
             if proper && types.is_considered_improper_ctype(&ty.inner) {

syntax/atom.rs

@@ -20,6 +20,7 @@ pub enum Atom {
     F64,
     CxxString,
     RustString,
+    CxxExceptionPtr,
 }
 
 impl Atom {
@@ -46,6 +47,7 @@ impl Atom {
             "f64" => Some(F64),
             "CxxString" => Some(CxxString),
             "String" => Some(RustString),
+            "CxxException" => Some(CxxExceptionPtr),
             _ => None,
         }
     }
@@ -77,6 +79,7 @@ impl AsRef<str> for Atom {
             F64 => "f64",
             CxxString => "CxxString",
             RustString => "String",
+            CxxExceptionPtr => "CxxException",
         }
     }
 }

syntax/check.rs

@@ -126,7 +126,7 @@ fn check_type_rust_vec(cx: &mut Check, ty: &Ty1) {
                 None | Some(Bool) | Some(Char) | Some(U8) | Some(U16) | Some(U32) | Some(U64)
                 | Some(Usize) | Some(I8) | Some(I16) | Some(I32) | Some(I64) | Some(Isize)
                 | Some(F32) | Some(F64) | Some(RustString) => return,
-                Some(CxxString) => {}
+                Some(CxxString) | Some(CxxExceptionPtr) => {}
             }
         }
         Type::Str(_) => return,
@@ -165,7 +165,7 @@ fn check_type_shared_ptr(cx: &mut Check, ptr: &Ty1) {
             None | Some(Bool) | Some(U8) | Some(U16) | Some(U32) | Some(U64) | Some(Usize)
             | Some(I8) | Some(I16) | Some(I32) | Some(I64) | Some(Isize) | Some(F32)
             | Some(F64) | Some(CxxString) => return,
-            Some(Char) | Some(RustString) => {}
+            Some(Char) | Some(RustString) | Some(CxxExceptionPtr) => {}
         }
     } else if let Type::CxxVector(_) = &ptr.inner {
         cx.error(ptr, "std::shared_ptr<std::vector> is not supported yet");
@@ -186,7 +186,7 @@ fn check_type_weak_ptr(cx: &mut Check, ptr: &Ty1) {
             None | Some(Bool) | Some(U8) | Some(U16) | Some(U32) | Some(U64) | Some(Usize)
             | Some(I8) | Some(I16) | Some(I32) | Some(I64) | Some(Isize) | Some(F32)
             | Some(F64) | Some(CxxString) => return,
-            Some(Char) | Some(RustString) => {}
+            Some(Char) | Some(RustString) | Some(CxxExceptionPtr) => {}
         }
     } else if let Type::CxxVector(_) = &ptr.inner {
         cx.error(ptr, "std::weak_ptr<std::vector> is not supported yet");
@@ -211,7 +211,7 @@ fn check_type_cxx_vector(cx: &mut Check, ptr: &Ty1) {
             | Some(I16) | Some(I32) | Some(I64) | Some(Isize) | Some(F32) | Some(F64)
             | Some(CxxString) => return,
             Some(Char) => { /* todo */ }
-            Some(Bool) | Some(RustString) => {}
+            Some(Bool) | Some(RustString) | Some(CxxExceptionPtr) => {}
         }
     }
 

syntax/pod.rs

@@ -10,7 +10,7 @@ impl<'a> Types<'a> {
                     match atom {
                         Bool | Char | U8 | U16 | U32 | U64 | Usize | I8 | I16 | I32 | I64
                         | Isize | F32 | F64 => true,
-                        CxxString | RustString => false,
+                        CxxString | RustString | CxxExceptionPtr => false,
                     }
                 } else if let Some(strct) = self.structs.get(ident) {
                     derive::contains(&strct.derives, Trait::Copy)

syntax/tokens.rs

@@ -14,7 +14,7 @@ impl ToTokens for Type {
                 if ident.rust == Char {
                     let span = ident.rust.span();
                     tokens.extend(quote_spanned!(span=> ::cxx::private::));
-                } else if ident.rust == CxxString {
+                } else if ident.rust == CxxString || ident.rust == CxxExceptionPtr {
                     let span = ident.rust.span();
                     tokens.extend(quote_spanned!(span=> ::cxx::));
                 } else if ident.rust == RustString {