Expose IncludeKind to cxx_gen library

Author: dtolnay

gen/cmd/src/app.rs

@@ -3,6 +3,8 @@
 mod test;
 
 use super::{Opt, Output};
+use crate::gen::include::Include;
+use crate::syntax::IncludeKind;
 use clap::AppSettings;
 use std::ffi::{OsStr, OsString};
 use std::path::PathBuf;
@@ -63,7 +65,19 @@ pub(super) fn from_args() -> Opt {
     let include = matches
         .values_of(INCLUDE)
         .unwrap_or_default()
-        .map(str::to_owned)
+        .map(|include| {
+            if include.starts_with('<') && include.ends_with('>') {
+                Include {
+                    path: include[1..include.len() - 1].to_owned(),
+                    kind: IncludeKind::Bracketed,
+                }
+            } else {
+                Include {
+                    path: include.to_owned(),
+                    kind: IncludeKind::Quoted,
+                }
+            }
+        })
         .collect();
 
     let mut outputs = Vec::new();

gen/cmd/src/main.rs

@@ -13,7 +13,8 @@ mod output;
 mod syntax;
 
 use crate::gen::error::{report, Result};
-use crate::gen::{fs, include};
+use crate::gen::fs;
+use crate::gen::include::{self, Include};
 use crate::output::Output;
 use std::io::{self, Write};
 use std::path::PathBuf;
@@ -24,7 +25,7 @@ struct Opt {
     input: Option<PathBuf>,
     header: bool,
     cxx_impl_annotations: Option<String>,
-    include: Vec<String>,
+    include: Vec<Include>,
     outputs: Vec<Output>,
 }
 

gen/lib/src/lib.rs

@@ -20,8 +20,9 @@ mod gen;
 mod syntax;
 
 pub use crate::error::Error;
-pub use crate::gen::include::HEADER;
+pub use crate::gen::include::{Include, HEADER};
 pub use crate::gen::{GeneratedCode, Opt};
+pub use crate::syntax::IncludeKind;
 use proc_macro2::TokenStream;
 
 /// Generate C++ bindings code from a Rust token stream. This should be a Rust

gen/src/include.rs

@@ -49,9 +49,16 @@ fn find_line(mut offset: usize, line: &str) -> Option<usize> {
     }
 }
 
-#[derive(PartialEq)]
+/// A header to #include.
+///
+/// The cxxbridge tool does not parse or even require the given paths to exist;
+/// they simply go into the generated C++ code as #include lines.
+#[derive(Clone, PartialEq, Debug)]
 pub struct Include {
+    /// The header's path, not including the enclosing quotation marks or angle
+    /// brackets.
     pub path: String,
+    /// Whether to emit `#include "path"` or `#include <path>`.
     pub kind: IncludeKind,
 }
 
@@ -82,12 +89,9 @@ impl Includes {
     }
 }
 
-impl<'a> Extend<&'a String> for Includes {
-    fn extend<I: IntoIterator<Item = &'a String>>(&mut self, iter: I) {
-        self.custom.extend(iter.into_iter().map(|path| Include {
-            path: path.clone(),
-            kind: IncludeKind::Quoted,
-        }));
+impl<'a> Extend<&'a Include> for Includes {
+    fn extend<I: IntoIterator<Item = &'a Include>>(&mut self, iter: I) {
+        self.custom.extend(iter.into_iter().cloned());
     }
 }
 

gen/src/mod.rs

@@ -11,6 +11,7 @@ mod write;
 pub(super) use self::error::Error;
 use self::error::{format_err, Result};
 use self::file::File;
+use self::include::Include;
 use crate::syntax::report::Errors;
 use crate::syntax::{self, check, Types};
 use std::path::Path;
@@ -34,7 +35,7 @@ pub struct Opt {
     /// Any additional headers to #include. The cxxbridge tool does not parse or
     /// even require the given paths to exist; they simply go into the generated
     /// C++ code as #include lines.
-    pub include: Vec<String>,
+    pub include: Vec<Include>,
     /// Optional annotation for implementations of C++ function wrappers that
     /// may be exposed to Rust. You may for example need to provide
     /// `__declspec(dllexport)` or `__attribute__((visibility("default")))` if

syntax/mod.rs

@@ -52,10 +52,13 @@ pub struct Include {
     pub end_span: Span,
 }
 
-#[derive(Copy, Clone, PartialEq)]
+/// Whether to emit `#include "path"` or `#include <path>`.
+#[derive(Copy, Clone, PartialEq, Debug)]
 pub enum IncludeKind {
-    Quoted,    // #include "quoted/path/to"
-    Bracketed, // #include <bracketed/path/to>
+    /// `#include "quoted/path/to"`
+    Quoted,
+    /// `#include <bracketed/path/to>`
+    Bracketed,
 }
 
 pub struct ExternType {