Merge pull request #922 from sdroege/assertion-configuration

Allow overriding safety assertions for functions

README.md

@@ -229,6 +229,9 @@ generate_builder = true
     no_future = true
     # to rename the generated function
     rename = "something_else"
+    # to override the default safety assertions: "none", "skip",
+    # "in-main-thread"
+    assertions = "in-main-thread"
         # override for parameter
         [[object.function.parameter]]
         # filter by name

src/analysis/functions.rs

@@ -535,6 +535,10 @@ fn analyze_function(
     let doc_hidden = configured_functions.iter().any(|f| f.doc_hidden);
     let disable_length_detect = configured_functions.iter().any(|f| f.disable_length_detect);
     let no_future = configured_functions.iter().any(|f| f.no_future);
+    let assertion = configured_functions
+        .iter()
+        .filter_map(|f| f.assertion)
+        .next();
 
     imports.set_defaults(version, &cfg_condition);
 
@@ -765,7 +769,8 @@ fn analyze_function(
         Visibility::Public
     };
     let is_method = func.kind == library::FunctionKind::Method;
-    let assertion = SafetyAssertionMode::of(env, is_method, &parameters);
+    let assertion =
+        assertion.unwrap_or_else(|| SafetyAssertionMode::of(env, is_method, &parameters));
 
     imports.reset_defaults();
 

src/analysis/safety_assertion_mode.rs

@@ -1,4 +1,5 @@
 use crate::{analysis::function_parameters::Parameters, env::Env, library};
+use std::str::FromStr;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum SafetyAssertionMode {
@@ -7,6 +8,19 @@ pub enum SafetyAssertionMode {
     InMainThread,
 }
 
+impl FromStr for SafetyAssertionMode {
+    type Err = String;
+    fn from_str(name: &str) -> Result<SafetyAssertionMode, String> {
+        use self::SafetyAssertionMode::*;
+        match name {
+            "none" => Ok(None),
+            "skip" => Ok(Skip),
+            "in-main-thread" => Ok(InMainThread),
+            _ => Err(format!("Unknown safety assertion mode '{}'", name)),
+        }
+    }
+}
+
 impl Default for SafetyAssertionMode {
     fn default() -> SafetyAssertionMode {
         SafetyAssertionMode::None

src/analysis/special_functions.rs

@@ -17,9 +17,9 @@ pub enum Type {
 }
 
 impl FromStr for Type {
-    type Err = ();
+    type Err = String;
 
-    fn from_str(s: &str) -> Result<Type, ()> {
+    fn from_str(s: &str) -> Result<Type, String> {
         use self::Type::*;
         match s {
             "compare" => Ok(Compare),
@@ -31,7 +31,7 @@ impl FromStr for Type {
             "to_string" => Ok(ToString),
             "unref" => Ok(Unref),
             "hash" => Ok(Hash),
-            _ => Err(()),
+            _ => Err(format!("Unknown type '{}'", s)),
         }
     }
 }

src/config/functions.rs

@@ -5,7 +5,9 @@ use super::{
     parsable::{Parsable, Parse},
     string_type::StringType,
 };
-use crate::{library::Nullable, version::Version};
+use crate::{
+    analysis::safety_assertion_mode::SafetyAssertionMode, library::Nullable, version::Version,
+};
 use log::error;
 use std::str::FromStr;
 use toml::Value;
@@ -202,6 +204,7 @@ pub struct Function {
     pub doc_trait_name: Option<String>,
     pub no_future: bool,
     pub rename: Option<String>,
+    pub assertion: Option<SafetyAssertionMode>,
 }
 
 impl Parse for Function {
@@ -231,6 +234,7 @@ impl Parse for Function {
                 "doc_trait_name",
                 "no_future",
                 "rename",
+                "assertion",
             ],
             &format!("function {}", object_name),
         );
@@ -277,6 +281,16 @@ impl Parse for Function {
             return None;
         }
 
+        let assertion = toml
+            .lookup("assertion")
+            .and_then(Value::as_str)
+            .map(|s| s.parse::<SafetyAssertionMode>())
+            .transpose();
+        if let Err(ref err) = assertion {
+            error!("{}", err);
+        }
+        let assertion = assertion.ok().flatten();
+
         Some(Function {
             ident,
             ignore,
@@ -290,6 +304,7 @@ impl Parse for Function {
             doc_trait_name,
             no_future,
             rename,
+            assertion,
         })
     }
 }

src/config/string_type.rs

@@ -14,7 +14,7 @@ impl FromStr for StringType {
             "utf8" => Ok(StringType::Utf8),
             "filename" => Ok(StringType::Filename),
             "os_string" => Ok(StringType::OsString),
-            _ => Err("Wrong string type".into()),
+            _ => Err(format!("Wrong string type '{}'", s)),
         }
     }
 }

src/config/work_mode.rs

@@ -39,7 +39,7 @@ impl FromStr for WorkMode {
             "sys" => Ok(WorkMode::Sys),
             "doc" => Ok(WorkMode::Doc),
             "not_bound" => Ok(WorkMode::DisplayNotBound),
-            _ => Err("Wrong work mode".into()),
+            _ => Err(format!("Wrong work mode '{}'", s)),
         }
     }
 }

src/library.rs

@@ -26,7 +26,7 @@ impl FromStr for Transfer {
             "none" => Ok(None),
             "container" => Ok(Container),
             "full" => Ok(Full),
-            _ => Err("Unknown ownership transfer mode".into()),
+            _ => Err(format!("Unknown ownership transfer mode '{}'", name)),
         }
     }
 }
@@ -53,7 +53,7 @@ impl FromStr for ParameterDirection {
             "in" => Ok(In),
             "out" => Ok(Out),
             "inout" => Ok(InOut),
-            _ => Err("Unknown parameter direction".into()),
+            _ => Err(format!("Unknown parameter direction '{}'", name)),
         }
     }
 }
@@ -153,7 +153,7 @@ impl FromStr for FunctionKind {
             "method" => Ok(Method),
             "callback" => Ok(Function),
             "global" => Ok(Global),
-            _ => Err("Unknown function kind".into()),
+            _ => Err(format!("Unknown function kind '{}'", name)),
         }
     }
 }
@@ -175,7 +175,7 @@ impl FromStr for Concurrency {
             "send-unique" => Ok(SendUnique),
             "send" => Ok(Send),
             "send+sync" => Ok(SendSync),
-            _ => Err("Unknown concurrency kind".into()),
+            _ => Err(format!("Unknown concurrency kind '{}'", name)),
         }
     }
 }