diff --git a/syntax/parse.rs b/syntax/parse.rs
index 2258dd6..10db16e 100644
--- a/syntax/parse.rs
+++ b/syntax/parse.rs
@@ -6,7 +6,8 @@
 use quote::quote;
 use syn::{
     Abi, Error, Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemType, GenericArgument, Item,
-    ItemForeignMod, ItemStruct, Pat, PathArguments, Result, ReturnType, Type as RustType,
+    ItemForeignMod, ItemStruct, Pat, PathArguments, Result, ReturnType, Type as RustType, TypePath,
+    TypeReference,
 };
 
 pub fn parse_items(items: Vec<Item>) -> Result<Vec<Api>> {
@@ -222,62 +223,64 @@
 
 fn parse_type(ty: &RustType) -> Result<Type> {
     match ty {
-        RustType::Reference(ty) => {
-            let inner = parse_type(&ty.elem)?;
-            let which = match &inner {
-                Type::Ident(ident) if ident == "str" => {
-                    if ty.mutability.is_some() {
-                        return Err(Error::new_spanned(ty, "unsupported type"));
-                    } else {
-                        Type::Str
-                    }
-                }
-                _ => Type::Ref,
-            };
-            return Ok(which(Box::new(Ref {
-                ampersand: ty.and_token,
-                mutability: ty.mutability,
-                inner,
-            })));
-        }
-        RustType::Path(ty) => {
-            let path = &ty.path;
-            if ty.qself.is_none() && path.leading_colon.is_none() && path.segments.len() == 1 {
-                let segment = &path.segments[0];
-                let ident = segment.ident.clone();
-                match &segment.arguments {
-                    PathArguments::None => return Ok(Type::Ident(ident)),
-                    PathArguments::AngleBracketed(generic) => {
-                        if ident == "UniquePtr" && generic.args.len() == 1 {
-                            if let GenericArgument::Type(arg) = &generic.args[0] {
-                                let inner = parse_type(arg)?;
-                                return Ok(Type::UniquePtr(Box::new(Ty1 {
-                                    name: ident,
-                                    langle: generic.lt_token,
-                                    inner,
-                                    rangle: generic.gt_token,
-                                })));
-                            }
-                        } else if ident == "Box" && generic.args.len() == 1 {
-                            if let GenericArgument::Type(arg) = &generic.args[0] {
-                                let inner = parse_type(arg)?;
-                                return Ok(Type::RustBox(Box::new(Ty1 {
-                                    name: ident,
-                                    langle: generic.lt_token,
-                                    inner,
-                                    rangle: generic.gt_token,
-                                })));
-                            }
-                        }
-                    }
-                    PathArguments::Parenthesized(_) => {}
-                }
+        RustType::Reference(ty) => parse_type_reference(ty),
+        RustType::Path(ty) => parse_type_path(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) -> Result<Type> {
+    let inner = parse_type(&ty.elem)?;
+    let which = match &inner {
+        Type::Ident(ident) if ident == "str" => {
+            if ty.mutability.is_some() {
+                return Err(Error::new_spanned(ty, "unsupported type"));
+            } else {
+                Type::Str
             }
         }
-        RustType::Tuple(ty) if ty.elems.is_empty() => {
-            return Ok(Type::Void(ty.paren_token.span));
+        _ => Type::Ref,
+    };
+    Ok(which(Box::new(Ref {
+        ampersand: ty.and_token,
+        mutability: ty.mutability,
+        inner,
+    })))
+}
+
+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];
+        let ident = segment.ident.clone();
+        match &segment.arguments {
+            PathArguments::None => return Ok(Type::Ident(ident)),
+            PathArguments::AngleBracketed(generic) => {
+                if ident == "UniquePtr" && generic.args.len() == 1 {
+                    if let GenericArgument::Type(arg) = &generic.args[0] {
+                        let inner = parse_type(arg)?;
+                        return Ok(Type::UniquePtr(Box::new(Ty1 {
+                            name: ident,
+                            langle: generic.lt_token,
+                            inner,
+                            rangle: generic.gt_token,
+                        })));
+                    }
+                } else if ident == "Box" && generic.args.len() == 1 {
+                    if let GenericArgument::Type(arg) = &generic.args[0] {
+                        let inner = parse_type(arg)?;
+                        return Ok(Type::RustBox(Box::new(Ty1 {
+                            name: ident,
+                            langle: generic.lt_token,
+                            inner,
+                            rangle: generic.gt_token,
+                        })));
+                    }
+                }
+            }
+            PathArguments::Parenthesized(_) => {}
         }
-        _ => {}
     }
     Err(Error::new_spanned(ty, "unsupported type"))
 }