Prefer namespace over ns
diff --git a/gen/src/alphasort.rs b/gen/src/alphasort.rs
index 5c21bc4..08ce4b4 100644
--- a/gen/src/alphasort.rs
+++ b/gen/src/alphasort.rs
@@ -29,8 +29,8 @@
let mut direct = Vec::new();
let mut nested_namespaces = BTreeMap::new();
for api in &apis {
- if let Some(ns) = api.namespace() {
- let first_ns_elem = ns.iter().nth(depth);
+ if let Some(namespace) = api.namespace() {
+ let first_ns_elem = namespace.iter().nth(depth);
if let Some(first_ns_elem) = first_ns_elem {
nested_namespaces
.entry(first_ns_elem)
diff --git a/macro/src/lib.rs b/macro/src/lib.rs
index 3796431..e55a08a 100644
--- a/macro/src/lib.rs
+++ b/macro/src/lib.rs
@@ -43,7 +43,7 @@
let _ = syntax::error::ERRORS;
let namespace = match Namespace::parse_bridge_attr_namespace.parse(args) {
- Ok(ns) => ns,
+ Ok(namespace) => namespace,
Err(err) => return err.to_compile_error().into(),
};
let mut ffi = parse_macro_input!(input as Module);
diff --git a/syntax/ident.rs b/syntax/ident.rs
index 354790a..03c4380 100644
--- a/syntax/ident.rs
+++ b/syntax/ident.rs
@@ -13,7 +13,7 @@
}
fn check_ident(cx: &mut Check, ident: &CppName) {
- for segment in &ident.ns {
+ for segment in &ident.namespace {
check(cx, segment);
}
check(cx, &ident.ident);
diff --git a/syntax/mangle.rs b/syntax/mangle.rs
index 9255feb..d1f3adc 100644
--- a/syntax/mangle.rs
+++ b/syntax/mangle.rs
@@ -15,13 +15,13 @@
Some(receiver) => {
let receiver_ident = types.resolve(&receiver.ty);
join!(
- efn.ident.cxx.ns,
+ efn.ident.cxx.namespace,
CXXBRIDGE,
receiver_ident.ident,
efn.ident.rust
)
}
- None => join!(efn.ident.cxx.ns, CXXBRIDGE, efn.ident.rust),
+ None => join!(efn.ident.cxx.namespace, CXXBRIDGE, efn.ident.rust),
}
}
diff --git a/syntax/mod.rs b/syntax/mod.rs
index 90af17f..b12d72b 100644
--- a/syntax/mod.rs
+++ b/syntax/mod.rs
@@ -197,7 +197,7 @@
// to output it as a qualified name or as an unqualfied name.
#[derive(Clone)]
pub struct CppName {
- pub ns: Namespace,
+ pub namespace: Namespace,
pub ident: Ident,
}
diff --git a/syntax/names.rs b/syntax/names.rs
index a61ffc3..ee010a9 100644
--- a/syntax/names.rs
+++ b/syntax/names.rs
@@ -5,19 +5,23 @@
impl Pair {
/// Use this constructor when the item can't have a different
/// name in Rust and C++.
- pub fn new(ns: Namespace, ident: Ident) -> Self {
+ pub fn new(namespace: Namespace, ident: Ident) -> Self {
Self {
rust: ident.clone(),
- cxx: CppName::new(ns, ident),
+ cxx: CppName::new(namespace, ident),
}
}
/// Use this constructor when attributes such as #[rust_name]
/// can be used to potentially give a different name in Rust vs C++.
- pub fn new_from_differing_names(ns: Namespace, cxx_ident: Ident, rust_ident: Ident) -> Self {
+ pub fn new_from_differing_names(
+ namespace: Namespace,
+ cxx_ident: Ident,
+ rust_ident: Ident,
+ ) -> Self {
Self {
rust: rust_ident,
- cxx: CppName::new(ns, cxx_ident),
+ cxx: CppName::new(namespace, cxx_ident),
}
}
}
@@ -47,12 +51,12 @@
}
impl CppName {
- pub fn new(ns: Namespace, ident: Ident) -> Self {
- Self { ns, ident }
+ pub fn new(namespace: Namespace, ident: Ident) -> Self {
+ Self { namespace, ident }
}
fn iter_all_segments(&self) -> impl Iterator<Item = &Ident> {
- self.ns.iter().chain(std::iter::once(&self.ident))
+ self.namespace.iter().chain(std::iter::once(&self.ident))
}
fn join(&self, sep: &str) -> String {
diff --git a/syntax/namespace.rs b/syntax/namespace.rs
index 7628b0a..02e5dc2 100644
--- a/syntax/namespace.rs
+++ b/syntax/namespace.rs
@@ -32,9 +32,9 @@
input.parse::<kw::namespace>()?;
input.parse::<Token![=]>()?;
- let ns = input.parse::<Namespace>()?;
+ let namespace = input.parse::<Namespace>()?;
input.parse::<Option<Token![,]>>()?;
- Ok(ns)
+ Ok(namespace)
}
}
@@ -88,10 +88,10 @@
impl Api {
pub fn namespace(&self) -> Option<&Namespace> {
match self {
- Api::CxxFunction(efn) | Api::RustFunction(efn) => Some(&efn.ident.cxx.ns),
- Api::CxxType(ety) | Api::RustType(ety) => Some(&ety.ident.cxx.ns),
- Api::Enum(enm) => Some(&enm.ident.cxx.ns),
- Api::Struct(strct) => Some(&strct.ident.cxx.ns),
+ Api::CxxFunction(efn) | Api::RustFunction(efn) => Some(&efn.ident.cxx.namespace),
+ Api::CxxType(ety) | Api::RustType(ety) => Some(&ety.ident.cxx.namespace),
+ Api::Enum(enm) => Some(&enm.ident.cxx.namespace),
+ Api::Struct(strct) => Some(&strct.ident.cxx.namespace),
Api::Impl(_) | Api::Include(_) | Api::TypeAlias(_) => None,
}
}
diff --git a/syntax/parse.rs b/syntax/parse.rs
index 1927554..c170f79 100644
--- a/syntax/parse.rs
+++ b/syntax/parse.rs
@@ -21,22 +21,27 @@
syn::custom_keyword!(Result);
}
-pub fn parse_items(cx: &mut Errors, items: Vec<Item>, trusted: bool, ns: &Namespace) -> Vec<Api> {
+pub fn parse_items(
+ cx: &mut Errors,
+ items: Vec<Item>,
+ trusted: bool,
+ namespace: &Namespace,
+) -> Vec<Api> {
let mut apis = Vec::new();
for item in items {
match item {
- Item::Struct(item) => match parse_struct(cx, item, ns.clone()) {
+ Item::Struct(item) => match parse_struct(cx, item, namespace.clone()) {
Ok(strct) => apis.push(strct),
Err(err) => cx.push(err),
},
- Item::Enum(item) => match parse_enum(cx, item, ns.clone()) {
+ Item::Enum(item) => match parse_enum(cx, item, namespace.clone()) {
Ok(enm) => apis.push(enm),
Err(err) => cx.push(err),
},
Item::ForeignMod(foreign_mod) => {
- parse_foreign_mod(cx, foreign_mod, &mut apis, trusted, ns)
+ parse_foreign_mod(cx, foreign_mod, &mut apis, trusted, namespace)
}
- Item::Impl(item) => match parse_impl(item, ns) {
+ Item::Impl(item) => match parse_impl(item, namespace) {
Ok(imp) => apis.push(imp),
Err(err) => cx.push(err),
},
@@ -47,7 +52,7 @@
apis
}
-fn parse_struct(cx: &mut Errors, item: ItemStruct, mut ns: Namespace) -> Result<Api> {
+fn parse_struct(cx: &mut Errors, item: ItemStruct, mut namespace: Namespace) -> Result<Api> {
let generics = &item.generics;
if !generics.params.is_empty() || generics.where_clause.is_some() {
let struct_token = item.struct_token;
@@ -68,7 +73,7 @@
attrs::Parser {
doc: Some(&mut doc),
derives: Some(&mut derives),
- namespace: Some(&mut ns),
+ namespace: Some(&mut namespace),
..Default::default()
},
);
@@ -85,7 +90,7 @@
doc,
derives,
struct_token: item.struct_token,
- ident: Pair::new(ns.clone(), item.ident),
+ ident: Pair::new(namespace.clone(), item.ident),
brace_token: fields.brace_token,
fields: fields
.named
@@ -93,14 +98,14 @@
.map(|field| {
Ok(Var {
ident: field.ident.unwrap(),
- ty: parse_type(&field.ty, &ns)?,
+ ty: parse_type(&field.ty, &namespace)?,
})
})
.collect::<Result<_>>()?,
}))
}
-fn parse_enum(cx: &mut Errors, item: ItemEnum, mut ns: Namespace) -> Result<Api> {
+fn parse_enum(cx: &mut Errors, item: ItemEnum, mut namespace: Namespace) -> Result<Api> {
let generics = &item.generics;
if !generics.params.is_empty() || generics.where_clause.is_some() {
let enum_token = item.enum_token;
@@ -121,7 +126,7 @@
attrs::Parser {
doc: Some(&mut doc),
repr: Some(&mut repr),
- namespace: Some(&mut ns),
+ namespace: Some(&mut namespace),
..Default::default()
},
);
@@ -172,7 +177,7 @@
Ok(Api::Enum(Enum {
doc,
enum_token,
- ident: Pair::new(ns, item.ident),
+ ident: Pair::new(namespace, item.ident),
brace_token,
variants,
repr,
@@ -184,7 +189,7 @@
foreign_mod: ItemForeignMod,
out: &mut Vec<Api>,
trusted: bool,
- ns: &Namespace,
+ namespace: &Namespace,
) {
let lang = match parse_lang(&foreign_mod.abi) {
Ok(lang) => lang,
@@ -209,12 +214,13 @@
for foreign in &foreign_mod.items {
match foreign {
ForeignItem::Type(foreign) => {
- match parse_extern_type(cx, foreign, lang, trusted, ns.clone()) {
+ match parse_extern_type(cx, foreign, lang, trusted, namespace.clone()) {
Ok(ety) => items.push(ety),
Err(err) => cx.push(err),
}
}
- ForeignItem::Fn(foreign) => match parse_extern_fn(cx, foreign, lang, ns.clone()) {
+ ForeignItem::Fn(foreign) => match parse_extern_fn(cx, foreign, lang, namespace.clone())
+ {
Ok(efn) => items.push(efn),
Err(err) => cx.push(err),
},
@@ -225,7 +231,7 @@
}
}
ForeignItem::Verbatim(tokens) => {
- match parse_extern_verbatim(cx, tokens, lang, ns.clone()) {
+ match parse_extern_verbatim(cx, tokens, lang, namespace.clone()) {
Ok(api) => items.push(api),
Err(err) => cx.push(err),
}
@@ -277,7 +283,7 @@
foreign_type: &ForeignItemType,
lang: Lang,
trusted: bool,
- mut ns: Namespace,
+ mut namespace: Namespace,
) -> Result<Api> {
let mut doc = Doc::new();
attrs::parse(
@@ -285,7 +291,7 @@
&foreign_type.attrs,
attrs::Parser {
doc: Some(&mut doc),
- namespace: Some(&mut ns),
+ namespace: Some(&mut namespace),
..Default::default()
},
);
@@ -299,7 +305,7 @@
Ok(api_type(ExternType {
doc,
type_token,
- ident: Pair::new(ns, ident),
+ ident: Pair::new(namespace, ident),
semi_token,
trusted,
}))
@@ -309,7 +315,7 @@
cx: &mut Errors,
foreign_fn: &ForeignItemFn,
lang: Lang,
- mut ns: Namespace,
+ mut namespace: Namespace,
) -> Result<Api> {
let generics = &foreign_fn.sig.generics;
if !generics.params.is_empty() || generics.where_clause.is_some() {
@@ -335,7 +341,7 @@
doc: Some(&mut doc),
cxx_name: Some(&mut cxx_name),
rust_name: Some(&mut rust_name),
- namespace: Some(&mut ns),
+ namespace: Some(&mut namespace),
..Default::default()
},
);
@@ -367,7 +373,7 @@
}
_ => return Err(Error::new_spanned(arg, "unsupported signature")),
};
- let ty = parse_type(&arg.ty, &ns)?;
+ let ty = parse_type(&arg.ty, &namespace)?;
if ident != "self" {
args.push_value(Var { ident, ty });
if let Some(comma) = comma {
@@ -394,12 +400,12 @@
}
let mut throws_tokens = None;
- let ret = parse_return_type(&foreign_fn.sig.output, &mut throws_tokens, &ns)?;
+ let ret = parse_return_type(&foreign_fn.sig.output, &mut throws_tokens, &namespace)?;
let throws = throws_tokens.is_some();
let unsafety = foreign_fn.sig.unsafety;
let fn_token = foreign_fn.sig.fn_token;
let ident = Pair::new_from_differing_names(
- ns,
+ namespace,
cxx_name.unwrap_or(foreign_fn.sig.ident.clone()),
rust_name.unwrap_or(foreign_fn.sig.ident.clone()),
);
@@ -432,7 +438,7 @@
cx: &mut Errors,
tokens: &TokenStream,
lang: Lang,
- mut ns: Namespace,
+ mut namespace: Namespace,
) -> Result<Api> {
// type Alias = crate::path::to::Type;
let parse = |input: ParseStream| -> Result<TypeAlias> {
@@ -454,7 +460,7 @@
&attrs,
attrs::Parser {
doc: Some(&mut doc),
- namespace: Some(&mut ns),
+ namespace: Some(&mut namespace),
..Default::default()
},
);
@@ -462,7 +468,7 @@
Ok(TypeAlias {
doc,
type_token,
- ident: Pair::new(ns, ident),
+ ident: Pair::new(namespace, ident),
eq_token,
ty,
semi_token,
@@ -481,7 +487,7 @@
}
}
-fn parse_impl(imp: ItemImpl, ns: &Namespace) -> Result<Api> {
+fn parse_impl(imp: ItemImpl, namespace: &Namespace) -> Result<Api> {
if !imp.items.is_empty() {
let mut span = Group::new(Delimiter::Brace, TokenStream::new());
span.set_span(imp.brace_token.span);
@@ -507,7 +513,7 @@
Ok(Api::Impl(Impl {
impl_token: imp.impl_token,
- ty: parse_type(&self_ty, ns)?,
+ ty: parse_type(&self_ty, namespace)?,
brace_token: imp.brace_token,
}))
}
@@ -556,19 +562,19 @@
Err(input.error("expected \"quoted/path/to\" or <bracketed/path/to>"))
}
-fn parse_type(ty: &RustType, ns: &Namespace) -> Result<Type> {
+fn parse_type(ty: &RustType, namespace: &Namespace) -> Result<Type> {
match ty {
- RustType::Reference(ty) => parse_type_reference(ty, ns),
- RustType::Path(ty) => parse_type_path(ty, ns),
- RustType::Slice(ty) => parse_type_slice(ty, ns),
- RustType::BareFn(ty) => parse_type_fn(ty, ns),
+ RustType::Reference(ty) => parse_type_reference(ty, namespace),
+ RustType::Path(ty) => parse_type_path(ty, namespace),
+ RustType::Slice(ty) => parse_type_slice(ty, namespace),
+ RustType::BareFn(ty) => parse_type_fn(ty, namespace),
RustType::Tuple(ty) if ty.elems.is_empty() => Ok(Type::Void(ty.paren_token.span)),
_ => Err(Error::new_spanned(ty, "unsupported type")),
}
}
-fn parse_type_reference(ty: &TypeReference, ns: &Namespace) -> Result<Type> {
- let inner = parse_type(&ty.elem, ns)?;
+fn parse_type_reference(ty: &TypeReference, namespace: &Namespace) -> Result<Type> {
+ let inner = parse_type(&ty.elem, namespace)?;
let which = match &inner {
Type::Ident(ident) if ident.rust == "str" => {
if ty.mutability.is_some() {
@@ -591,7 +597,7 @@
})))
}
-fn parse_type_path(ty: &TypePath, ns: &Namespace) -> Result<Type> {
+fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
let path = &ty.path;
if ty.qself.is_none() && path.leading_colon.is_none() && path.segments.len() == 1 {
let segment = &path.segments[0];
@@ -602,7 +608,7 @@
PathArguments::AngleBracketed(generic) => {
if ident == "UniquePtr" && generic.args.len() == 1 {
if let GenericArgument::Type(arg) = &generic.args[0] {
- let inner = parse_type(arg, ns)?;
+ let inner = parse_type(arg, namespace)?;
return Ok(Type::UniquePtr(Box::new(Ty1 {
name: maybe_resolved_ident,
langle: generic.lt_token,
@@ -612,7 +618,7 @@
}
} else if ident == "CxxVector" && generic.args.len() == 1 {
if let GenericArgument::Type(arg) = &generic.args[0] {
- let inner = parse_type(arg, ns)?;
+ let inner = parse_type(arg, namespace)?;
return Ok(Type::CxxVector(Box::new(Ty1 {
name: maybe_resolved_ident,
langle: generic.lt_token,
@@ -622,7 +628,7 @@
}
} else if ident == "Box" && generic.args.len() == 1 {
if let GenericArgument::Type(arg) = &generic.args[0] {
- let inner = parse_type(arg, ns)?;
+ let inner = parse_type(arg, namespace)?;
return Ok(Type::RustBox(Box::new(Ty1 {
name: maybe_resolved_ident,
langle: generic.lt_token,
@@ -632,7 +638,7 @@
}
} else if ident == "Vec" && generic.args.len() == 1 {
if let GenericArgument::Type(arg) = &generic.args[0] {
- let inner = parse_type(arg, ns)?;
+ let inner = parse_type(arg, namespace)?;
return Ok(Type::RustVec(Box::new(Ty1 {
name: maybe_resolved_ident,
langle: generic.lt_token,
@@ -648,15 +654,15 @@
Err(Error::new_spanned(ty, "unsupported type"))
}
-fn parse_type_slice(ty: &TypeSlice, ns: &Namespace) -> Result<Type> {
- let inner = parse_type(&ty.elem, ns)?;
+fn parse_type_slice(ty: &TypeSlice, namespace: &Namespace) -> Result<Type> {
+ let inner = parse_type(&ty.elem, namespace)?;
Ok(Type::Slice(Box::new(Slice {
bracket: ty.bracket_token,
inner,
})))
}
-fn parse_type_fn(ty: &TypeBareFn, ns: &Namespace) -> Result<Type> {
+fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
if ty.lifetimes.is_some() {
return Err(Error::new_spanned(
ty,
@@ -674,7 +680,7 @@
.iter()
.enumerate()
.map(|(i, arg)| {
- let ty = parse_type(&arg.ty, ns)?;
+ let ty = parse_type(&arg.ty, namespace)?;
let ident = match &arg.name {
Some(ident) => ident.0.clone(),
None => format_ident!("_{}", i),
@@ -683,7 +689,7 @@
})
.collect::<Result<_>>()?;
let mut throws_tokens = None;
- let ret = parse_return_type(&ty.output, &mut throws_tokens, ns)?;
+ let ret = parse_return_type(&ty.output, &mut throws_tokens, namespace)?;
let throws = throws_tokens.is_some();
Ok(Type::Fn(Box::new(Signature {
unsafety: ty.unsafety,
@@ -700,7 +706,7 @@
fn parse_return_type(
ty: &ReturnType,
throws_tokens: &mut Option<(kw::Result, Token![<], Token![>])>,
- ns: &Namespace,
+ namespace: &Namespace,
) -> Result<Option<Type>> {
let mut ret = match ty {
ReturnType::Default => return Ok(None),
@@ -722,7 +728,7 @@
}
}
}
- match parse_type(ret, ns)? {
+ match parse_type(ret, namespace)? {
Type::Void(_) => Ok(None),
ty => Ok(Some(ty)),
}
diff --git a/syntax/symbol.rs b/syntax/symbol.rs
index 0b79d5f..c849a62 100644
--- a/syntax/symbol.rs
+++ b/syntax/symbol.rs
@@ -81,7 +81,7 @@
impl Segment for CppName {
fn write(&self, symbol: &mut Symbol) {
- self.ns.write(symbol);
+ self.namespace.write(symbol);
self.ident.write(symbol);
}
}
