diff --git a/syntax/parse.rs b/syntax/parse.rs
index 2c8d98239..15ee4f24e 100644
--- a/syntax/parse.rs
+++ b/syntax/parse.rs
@@ -43,7 +43,7 @@ pub fn parse_items(
             Item::ForeignMod(foreign_mod) => {
                 parse_foreign_mod(cx, foreign_mod, &mut apis, trusted, namespace)
             }
-            Item::Impl(item) => match parse_impl(item, namespace) {
+            Item::Impl(item) => match parse_impl(item) {
                 Ok(imp) => apis.push(imp),
                 Err(err) => cx.push(err),
             },
@@ -95,7 +95,7 @@ fn parse_struct(cx: &mut Errors, item: ItemStruct, namespace: &Namespace) -> Res
         .map(|field| {
             Ok(Var {
                 ident: field.ident.unwrap(),
-                ty: parse_type(&field.ty, &namespace)?,
+                ty: parse_type(&field.ty)?,
             })
         })
         .collect::<Result<_>>()?;
@@ -438,7 +438,7 @@ fn parse_extern_fn(
                     }
                     _ => return Err(Error::new_spanned(arg, "unsupported signature")),
                 };
-                let ty = parse_type(&arg.ty, &namespace)?;
+                let ty = parse_type(&arg.ty)?;
                 if ident != "self" {
                     args.push_value(Var { ident, ty });
                     if let Some(comma) = comma {
@@ -468,7 +468,7 @@ fn parse_extern_fn(
     }
 
     let mut throws_tokens = None;
-    let ret = parse_return_type(&foreign_fn.sig.output, &mut throws_tokens, &namespace)?;
+    let ret = parse_return_type(&foreign_fn.sig.output, &mut throws_tokens)?;
     let throws = throws_tokens.is_some();
     let unsafety = foreign_fn.sig.unsafety;
     let fn_token = foreign_fn.sig.fn_token;
@@ -559,7 +559,7 @@ fn parse_extern_verbatim(
     }
 }
 
-fn parse_impl(imp: ItemImpl, namespace: &Namespace) -> Result<Api> {
+fn parse_impl(imp: ItemImpl) -> Result<Api> {
     if !imp.items.is_empty() {
         let mut span = Group::new(Delimiter::Brace, TokenStream::new());
         span.set_span(imp.brace_token.span);
@@ -585,7 +585,7 @@ fn parse_impl(imp: ItemImpl, namespace: &Namespace) -> Result<Api> {
 
     Ok(Api::Impl(Impl {
         impl_token: imp.impl_token,
-        ty: parse_type(&self_ty, namespace)?,
+        ty: parse_type(&self_ty)?,
         brace_token: imp.brace_token,
     }))
 }
@@ -634,20 +634,20 @@ fn parse_include(input: ParseStream) -> Result<Include> {
     Err(input.error("expected \"quoted/path/to\" or <bracketed/path/to>"))
 }
 
-fn parse_type(ty: &RustType, namespace: &Namespace) -> Result<Type> {
+fn parse_type(ty: &RustType) -> Result<Type> {
     match ty {
-        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::Array(ty) => parse_type_array(ty, namespace),
-        RustType::BareFn(ty) => parse_type_fn(ty, namespace),
+        RustType::Reference(ty) => parse_type_reference(ty),
+        RustType::Path(ty) => parse_type_path(ty),
+        RustType::Slice(ty) => parse_type_slice(ty),
+        RustType::Array(ty) => parse_type_array(ty),
+        RustType::BareFn(ty) => parse_type_fn(ty),
         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, namespace: &Namespace) -> Result<Type> {
-    let inner = parse_type(&ty.elem, namespace)?;
+fn parse_type_reference(ty: &TypeReference) -> Result<Type> {
+    let inner = parse_type(&ty.elem)?;
     let which = match &inner {
         Type::Ident(ident) if ident.rust == "str" => {
             if ty.mutability.is_some() {
@@ -673,7 +673,7 @@ fn parse_type_reference(ty: &TypeReference, namespace: &Namespace) -> Result<Typ
     })))
 }
 
-fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
+fn parse_type_path(ty: &TypePath) -> 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];
@@ -683,7 +683,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
             PathArguments::AngleBracketed(generic) => {
                 if ident == "UniquePtr" && generic.args.len() == 1 {
                     if let GenericArgument::Type(arg) = &generic.args[0] {
-                        let inner = parse_type(arg, namespace)?;
+                        let inner = parse_type(arg)?;
                         return Ok(Type::UniquePtr(Box::new(Ty1 {
                             name: ident,
                             langle: generic.lt_token,
@@ -693,7 +693,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
                     }
                 } else if ident == "CxxVector" && generic.args.len() == 1 {
                     if let GenericArgument::Type(arg) = &generic.args[0] {
-                        let inner = parse_type(arg, namespace)?;
+                        let inner = parse_type(arg)?;
                         return Ok(Type::CxxVector(Box::new(Ty1 {
                             name: ident,
                             langle: generic.lt_token,
@@ -703,7 +703,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
                     }
                 } else if ident == "Box" && generic.args.len() == 1 {
                     if let GenericArgument::Type(arg) = &generic.args[0] {
-                        let inner = parse_type(arg, namespace)?;
+                        let inner = parse_type(arg)?;
                         return Ok(Type::RustBox(Box::new(Ty1 {
                             name: ident,
                             langle: generic.lt_token,
@@ -713,7 +713,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
                     }
                 } else if ident == "Vec" && generic.args.len() == 1 {
                     if let GenericArgument::Type(arg) = &generic.args[0] {
-                        let inner = parse_type(arg, namespace)?;
+                        let inner = parse_type(arg)?;
                         return Ok(Type::RustVec(Box::new(Ty1 {
                             name: ident,
                             langle: generic.lt_token,
@@ -723,7 +723,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
                     }
                 } else if ident == "Pin" && generic.args.len() == 1 {
                     if let GenericArgument::Type(arg) = &generic.args[0] {
-                        let inner = parse_type(arg, namespace)?;
+                        let inner = parse_type(arg)?;
                         let pin_token = kw::Pin(ident.span());
                         if let Type::Ref(mut inner) = inner {
                             inner.pinned = true;
@@ -740,16 +740,16 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
     Err(Error::new_spanned(ty, "unsupported type"))
 }
 
-fn parse_type_slice(ty: &TypeSlice, namespace: &Namespace) -> Result<Type> {
-    let inner = parse_type(&ty.elem, namespace)?;
+fn parse_type_slice(ty: &TypeSlice) -> Result<Type> {
+    let inner = parse_type(&ty.elem)?;
     Ok(Type::Slice(Box::new(Slice {
         bracket: ty.bracket_token,
         inner,
     })))
 }
 
-fn parse_type_array(ty: &TypeArray, namespace: &Namespace) -> Result<Type> {
-    let inner = parse_type(&ty.elem, namespace)?;
+fn parse_type_array(ty: &TypeArray) -> Result<Type> {
+    let inner = parse_type(&ty.elem)?;
 
     let len_expr = if let Expr::Lit(lit) = &ty.len {
         lit
@@ -778,7 +778,7 @@ fn parse_type_array(ty: &TypeArray, namespace: &Namespace) -> Result<Type> {
     })))
 }
 
-fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
+fn parse_type_fn(ty: &TypeBareFn) -> Result<Type> {
     if ty.lifetimes.is_some() {
         return Err(Error::new_spanned(
             ty,
@@ -796,7 +796,7 @@ fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
         .iter()
         .enumerate()
         .map(|(i, arg)| {
-            let ty = parse_type(&arg.ty, namespace)?;
+            let ty = parse_type(&arg.ty)?;
             let ident = match &arg.name {
                 Some(ident) => ident.0.clone(),
                 None => format_ident!("_{}", i),
@@ -805,7 +805,7 @@ fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
         })
         .collect::<Result<_>>()?;
     let mut throws_tokens = None;
-    let ret = parse_return_type(&ty.output, &mut throws_tokens, namespace)?;
+    let ret = parse_return_type(&ty.output, &mut throws_tokens)?;
     let throws = throws_tokens.is_some();
     Ok(Type::Fn(Box::new(Signature {
         unsafety: ty.unsafety,
@@ -823,7 +823,6 @@ fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
 fn parse_return_type(
     ty: &ReturnType,
     throws_tokens: &mut Option<(kw::Result, Token![<], Token![>])>,
-    namespace: &Namespace,
 ) -> Result<Option<Type>> {
     let mut ret = match ty {
         ReturnType::Default => return Ok(None),
@@ -845,7 +844,7 @@ fn parse_return_type(
             }
         }
     }
-    match parse_type(ret, namespace)? {
+    match parse_type(ret)? {
         Type::Void(_) => Ok(None),
         ty => Ok(Some(ty)),
     }