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);
     }
 }