commit 285779635a47ce922afc294bb3bab8c8764f20cd
author David Tolnay <dtolnay@gmail.com> Mon Mar 22 15:53:36 2021 -0700
committer David Tolnay <dtolnay@gmail.com> Mon Mar 22 19:12:06 2021 -0700
tree e15802fe273074d3bb1db3d48784beb50a8f34dd
parent a3ef34f95bc18a8ec7c7c6d8768d002062345221

Defer unsafety check for fn with ptr argument

That error does not need to be fatal at parse time, because the parser
still understands exactly what was written. We accumulate and emit it
alongside other type errors that might be present in the same function
signature.

syntax/parse.rs

diff --git a/syntax/parse.rs b/syntax/parse.rs
index 51b5e4b..d792076 100644
--- a/syntax/parse.rs
+++ b/syntax/parse.rs
@@ -547,7 +547,6 @@
         ));
     }
 
-    let unsafety = foreign_fn.sig.unsafety;
     let mut receiver = None;
     let mut args = Punctuated::new();
     for arg in foreign_fn.sig.inputs.pairs() {
@@ -584,14 +583,6 @@
                     let attrs = OtherAttrs::none();
                     let visibility = Token![pub](ident.span());
                     let name = pair(Namespace::default(), &ident, None, None);
-                    if let Type::Ptr(_) = &ty {
-                        if unsafety.is_none() {
-                            return Err(Error::new_spanned(
-                                arg,
-                                "pointer argument requires that the function be marked unsafe",
-                            ));
-                        }
-                    }
                     args.push_value(Var {
                         doc,
                         attrs,
@@ -628,6 +619,7 @@
     let mut throws_tokens = None;
     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;
     let inherited_span = unsafety.map_or(fn_token.span, |unsafety| unsafety.span);
     let visibility = visibility_pub(&foreign_fn.vis, inherited_span);