Merge pull request #259 from markbt/warnings

Fix or suppress warnings and format code

Author: markbt

Makefile

@@ -56,6 +56,9 @@ endif
 doc: build
 	cargo doc --no-deps $(CARGO_FLAGS)
 
+clippy:
+	cargo clippy $(CARGO_FLAGS)
+
 extensions: build
 	make -C extensions/tests PY=$(PY)
 

build.rs

@@ -1,49 +1,44 @@
 use std::env;
-use std::io::Write;
 
-const CFG_KEY: &'static str = "py_sys_config";
+const CFG_KEY: &str = "py_sys_config";
 
 #[cfg(feature = "python27-sys")]
-const PYTHONSYS_ENV_VAR: &'static str = "DEP_PYTHON27_PYTHON_FLAGS";
+const PYTHONSYS_ENV_VAR: &str = "DEP_PYTHON27_PYTHON_FLAGS";
 
 #[cfg(feature = "python3-sys")]
-const PYTHONSYS_ENV_VAR: &'static str = "DEP_PYTHON3_PYTHON_FLAGS";
+const PYTHONSYS_ENV_VAR: &str = "DEP_PYTHON3_PYTHON_FLAGS";
 
 fn main() {
-    if cfg!(feature = "python27-sys") {
-        if env::var_os("CARGO_FEATURE_PY_LINK_MODE_DEFAULT").is_some()
-            || env::var_os("CARGO_FEATURE_PY_LINK_MODE_UNRESOLVED_STATIC").is_some()
-        {
-            writeln!(
-                std::io::stderr(),
-                "Cannot use link mode control with Python 2.7"
-            )
-            .unwrap();
-            std::process::exit(1);
-        }
+    if cfg!(feature = "python27-sys")
+        && (env::var_os("CARGO_FEATURE_PY_LINK_MODE_DEFAULT").is_some()
+            || env::var_os("CARGO_FEATURE_PY_LINK_MODE_UNRESOLVED_STATIC").is_some())
+    {
+        eprintln!("Cannot use link mode control with Python 2.7");
+        std::process::exit(1);
     }
 
     // python{27,3.x}-sys/build.rs passes python interpreter compile flags via
     // environment variable (using the 'links' mechanism in the cargo.toml).
     let flags = match env::var(PYTHONSYS_ENV_VAR) {
         Ok(flags) => flags,
         Err(_) => {
-            writeln!(
-                std::io::stderr(),
-                "Environment variable {} not found - this is supposed to be \
-                 exported from the pythonXX-sys dependency, so the build chain is broken",
+            eprintln!(
+                concat!(
+                    "Environment variable {} not found - this is supposed to be ",
+                    "exported from the pythonXX-sys dependency, so the build ",
+                    "chain is broken"
+                ),
                 PYTHONSYS_ENV_VAR
-            )
-            .unwrap();
+            );
             std::process::exit(1);
         }
     };
 
-    if flags.len() > 0 {
-        for f in flags.split(",") {
+    if !flags.is_empty() {
+        for f in flags.split(',') {
             // write out flags as --cfg so that the same #cfg blocks can be used
             // in rust-cpython as in the -sys libs
-            let key_and_val: Vec<&str> = f.split("=").collect();
+            let key_and_val: Vec<&str> = f.split('=').collect();
             let key = key_and_val[0];
             let val = key_and_val[1];
             if key.starts_with("FLAG") {

python27-sys/build.rs

@@ -25,15 +25,15 @@ impl fmt::Display for PythonVersion {
     }
 }
 
-const CFG_KEY: &'static str = "py_sys_config";
+const CFG_KEY: &str = "py_sys_config";
 
 // windows' python writes out lines with the windows crlf sequence;
 // posix platforms and mac os should write out lines with just lf.
 #[cfg(target_os = "windows")]
-static NEWLINE_SEQUENCE: &'static str = "\r\n";
+static NEWLINE_SEQUENCE: &str = "\r\n";
 
 #[cfg(not(target_os = "windows"))]
-static NEWLINE_SEQUENCE: &'static str = "\n";
+static NEWLINE_SEQUENCE: &str = "\n";
 
 // A list of python interpreter compile-time preprocessor defines that
 // we will pick up and pass to rustc via --cfg=py_sys_config={varname};
@@ -48,7 +48,7 @@ static NEWLINE_SEQUENCE: &'static str = "\n";
 // (hrm, this is sort of re-implementing what distutils does, except
 // by passing command line args instead of referring to a python.h)
 #[cfg(not(target_os = "windows"))]
-static SYSCONFIG_FLAGS: [&'static str; 7] = [
+static SYSCONFIG_FLAGS: [&str; 7] = [
     "Py_USING_UNICODE",
     "Py_UNICODE_WIDE",
     "WITH_THREAD",
@@ -58,7 +58,7 @@ static SYSCONFIG_FLAGS: [&'static str; 7] = [
     "COUNT_ALLOCS",
 ];
 
-static SYSCONFIG_VALUES: [&'static str; 1] = [
+static SYSCONFIG_VALUES: [&str; 1] = [
     // cfg doesn't support flags with values, just bools - so flags
     // below are translated into bools as {varname}_{val}
     //
@@ -70,7 +70,7 @@ static SYSCONFIG_VALUES: [&'static str; 1] = [
 /// the interpreter and printing variables of interest from
 /// sysconfig.get_config_vars.
 #[cfg(not(target_os = "windows"))]
-fn get_config_vars(python_path: &String) -> Result<HashMap<String, String>, String> {
+fn get_config_vars(python_path: &str) -> Result<HashMap<String, String>, String> {
     let mut script = "import sysconfig; \
                       config = sysconfig.get_config_vars();"
         .to_owned();
@@ -81,7 +81,7 @@ fn get_config_vars(python_path: &String) -> Result<HashMap<String, String>, Stri
             k,
             if is_value(k) { "None" } else { "0" }
         ));
-        script.push_str(";");
+        script.push(';');
     }
 
     let mut cmd = Command::new(python_path);
@@ -93,7 +93,7 @@ fn get_config_vars(python_path: &String) -> Result<HashMap<String, String>, Stri
 
     if !out.status.success() {
         let stderr = String::from_utf8(out.stderr).unwrap();
-        let mut msg = format!("python script failed with stderr:\n\n");
+        let mut msg = "python script failed with stderr:\n\n".to_string();
         msg.push_str(&stderr);
         return Err(msg);
     }
@@ -105,15 +105,14 @@ fn get_config_vars(python_path: &String) -> Result<HashMap<String, String>, Stri
             "python stdout len didn't return expected number of lines:
 {}",
             split_stdout.len()
-        )
-        .to_string());
+        ));
     }
     let all_vars = SYSCONFIG_FLAGS.iter().chain(SYSCONFIG_VALUES.iter());
     // let var_map: HashMap<String, String> = HashMap::new();
     Ok(all_vars.zip(split_stdout.iter()).fold(
         HashMap::new(),
         |mut memo: HashMap<String, String>, (&k, &v)| {
-            if !(v.to_owned() == "None" && is_value(k)) {
+            if !(v == "None" && is_value(k)) {
                 memo.insert(k.to_owned(), v.to_owned());
             }
             memo
@@ -122,7 +121,7 @@ fn get_config_vars(python_path: &String) -> Result<HashMap<String, String>, Stri
 }
 
 #[cfg(target_os = "windows")]
-fn get_config_vars(_: &String) -> Result<HashMap<String, String>, String> {
+fn get_config_vars(_: &str) -> Result<HashMap<String, String>, String> {
     // sysconfig is missing all the flags on windows, so we can't actually
     // query the interpreter directly for its build flags.
     //
@@ -151,7 +150,7 @@ fn get_config_vars(_: &String) -> Result<HashMap<String, String>, String> {
 }
 
 fn is_value(key: &str) -> bool {
-    SYSCONFIG_VALUES.iter().find(|x| **x == key).is_some()
+    SYSCONFIG_VALUES.iter().any(|x| *x == key)
 }
 
 fn cfg_line_for_var(key: &str, val: &str) -> Option<String> {
@@ -185,17 +184,17 @@ fn run_python_script(interpreter: &str, script: &str) -> Result<String, String>
 
     if !out.status.success() {
         let stderr = String::from_utf8(out.stderr).unwrap();
-        let mut msg = format!("python script failed with stderr:\n\n");
+        let mut msg = "python script failed with stderr:\n\n".to_string();
         msg.push_str(&stderr);
         return Err(msg);
     }
 
-    let out = String::from_utf8(out.stdout).unwrap();
-    return Ok(out);
+    Ok(String::from_utf8(out.stdout).unwrap())
 }
 
 #[cfg(not(target_os = "macos"))]
 #[cfg(not(target_os = "windows"))]
+#[allow(clippy::unnecessary_wraps)]
 fn get_rustc_link_lib(
     _: &PythonVersion,
     ld_version: &str,
@@ -278,7 +277,7 @@ fn find_interpreter_and_get_config(
         let (executable, interpreter_version, lines) =
             get_config_from_interpreter(interpreter_path)?;
         if matching_version(expected_version, &interpreter_version) {
-            return Ok((interpreter_version, executable.to_owned(), lines));
+            return Ok((interpreter_version, executable, lines));
         } else {
             return Err(format!(
                 "Wrong python version in PYTHON_SYS_EXECUTABLE={}\n\
@@ -297,11 +296,9 @@ fn find_interpreter_and_get_config(
     }
 
     for name in possible_names.iter() {
-        if let Some((executable, interpreter_version, lines)) =
-            get_config_from_interpreter(name).ok()
-        {
+        if let Ok((executable, interpreter_version, lines)) = get_config_from_interpreter(name) {
             if matching_version(expected_version, &interpreter_version) {
-                return Ok((interpreter_version, executable.to_owned(), lines));
+                return Ok((interpreter_version, executable, lines));
             }
         }
     }
@@ -371,20 +368,18 @@ fn configure_from_path(expected_version: &PythonVersion) -> Result<String, Strin
                 println!("cargo:rustc-link-search=native={}\\libs", exec_prefix);
             }
         }
-    } else if link_mode_unresolved_static {
-        if cfg!(target_os = "windows") {
-            // static-nobundle requires a Nightly rustc up to at least
-            // Rust 1.39 (https://github.com/rust-lang/rust/issues/37403).
-            //
-            // We need to use static linking on Windows to prevent symbol
-            // name mangling. Otherwise Rust will prefix extern {} symbols
-            // with __imp_. But if we used normal "static," we need a
-            // pythonXY.lib at build time to package into the rlib.
-            //
-            // static-nobundle removes the build-time library requirement,
-            // allowing a downstream consumer to provide the pythonXY library.
-            println!("cargo:rustc-link-lib=static-nobundle=pythonXY");
-        }
+    } else if link_mode_unresolved_static && cfg!(target_os = "windows") {
+        // static-nobundle requires a Nightly rustc up to at least
+        // Rust 1.39 (https://github.com/rust-lang/rust/issues/37403).
+        //
+        // We need to use static linking on Windows to prevent symbol
+        // name mangling. Otherwise Rust will prefix extern {} symbols
+        // with __imp_. But if we used normal "static," we need a
+        // pythonXY.lib at build time to package into the rlib.
+        //
+        // static-nobundle removes the build-time library requirement,
+        // allowing a downstream consumer to provide the pythonXY library.
+        println!("cargo:rustc-link-lib=static-nobundle=pythonXY");
     }
 
     if let PythonVersion {
@@ -402,7 +397,7 @@ fn configure_from_path(expected_version: &PythonVersion) -> Result<String, Strin
         }
     }
 
-    return Ok(interpreter_path);
+    Ok(interpreter_path)
 }
 
 /// Determine the python version we're supposed to be building
@@ -418,17 +413,11 @@ fn version_from_env() -> Result<PythonVersion, String> {
     let mut vars = env::vars().collect::<Vec<_>>();
     vars.sort_by(|a, b| b.cmp(a));
     for (key, _) in vars {
-        match re.captures(&key) {
-            Some(cap) => {
-                return Ok(PythonVersion {
-                    major: cap.get(1).unwrap().as_str().parse().unwrap(),
-                    minor: match cap.get(3) {
-                        Some(s) => Some(s.as_str().parse().unwrap()),
-                        None => None,
-                    },
-                })
-            }
-            None => (),
+        if let Some(cap) = re.captures(&key) {
+            return Ok(PythonVersion {
+                major: cap.get(1).unwrap().as_str().parse().unwrap(),
+                minor: cap.get(3).map(|s| s.as_str().parse().unwrap()),
+            });
         }
     }
     Err(
@@ -459,9 +448,8 @@ fn main() {
         config_map.insert("Py_REF_DEBUG".to_owned(), "1".to_owned()); // Py_TRACE_REFS implies Py_REF_DEBUG.
     }
     for (key, val) in &config_map {
-        match cfg_line_for_var(key, val) {
-            Some(line) => println!("{}", line),
-            None => (),
+        if let Some(line) = cfg_line_for_var(key, val) {
+            println!("{}", line);
         }
     }
 
@@ -489,7 +477,7 @@ fn main() {
     });
     println!(
         "cargo:python_flags={}",
-        if flags.len() > 0 {
+        if !flags.is_empty() {
             &flags[..flags.len() - 1]
         } else {
             ""

python27-sys/src/code.rs

@@ -78,9 +78,15 @@ extern "C" {
         firstlineno: c_int,
     ) -> *mut PyCodeObject;
     pub fn PyCode_Addr2Line(arg1: *mut PyCodeObject, arg2: c_int) -> c_int;
-    //fn _PyCode_CheckLineNumber(co: *mut PyCodeObject,
-    //                               lasti: c_int,
-    //                               bounds: *mut PyAddrPair) -> c_int;
+
+    ignore! {
+        fn _PyCode_CheckLineNumber(
+            co: *mut PyCodeObject,
+            lasti: c_int,
+            bounds: *mut PyAddrPair,
+        ) -> c_int;
+    }
+
     pub fn PyCode_Optimize(
         code: *mut PyObject,
         consts: *mut PyObject,

python27-sys/src/compile.rs

@@ -11,13 +11,13 @@ pub struct PyFutureFeatures {
     pub ff_lineno: c_int,
 }
 
-pub const FUTURE_NESTED_SCOPES: &'static str = "nested_scopes";
-pub const FUTURE_GENERATORS: &'static str = "generators";
-pub const FUTURE_DIVISION: &'static str = "division";
-pub const FUTURE_ABSOLUTE_IMPORT: &'static str = "absolute_import";
-pub const FUTURE_WITH_STATEMENT: &'static str = "with_statement";
-pub const FUTURE_PRINT_FUNCTION: &'static str = "print_function";
-pub const FUTURE_UNICODE_LITERALS: &'static str = "unicode_literals";
+pub const FUTURE_NESTED_SCOPES: &str = "nested_scopes";
+pub const FUTURE_GENERATORS: &str = "generators";
+pub const FUTURE_DIVISION: &str = "division";
+pub const FUTURE_ABSOLUTE_IMPORT: &str = "absolute_import";
+pub const FUTURE_WITH_STATEMENT: &str = "with_statement";
+pub const FUTURE_PRINT_FUNCTION: &str = "print_function";
+pub const FUTURE_UNICODE_LITERALS: &str = "unicode_literals";
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {

python27-sys/src/complexobject.rs

@@ -57,8 +57,11 @@ extern "C" {
     pub fn PyComplex_ImagAsDouble(op: *mut PyObject) -> c_double;
     pub fn PyComplex_AsCComplex(op: *mut PyObject) -> Py_complex;
 
-//fn _PyComplex_FormatAdvanced(obj: *mut PyObject,
-//                                 format_spec: *mut c_char,
-//                                 format_spec_len: Py_ssize_t)
-// -> *mut PyObject;
+    ignore! {
+        fn _PyComplex_FormatAdvanced(
+            obj: *mut PyObject,
+            format_spec: *mut c_char,
+            format_spec_len: Py_ssize_t,
+        ) -> *mut PyObject;
+    }
 }

python27-sys/src/descrobject.rs

@@ -87,7 +87,9 @@ pub unsafe fn PyDescr_IsData(d: *mut PyObject) -> c_int {
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
-    //pub fn PyDictProxy_New(arg1: *mut PyObject) -> *mut PyObject;
-    // PyDictProxy_New is also defined in dictobject.h
+    ignore! {
+        // PyDictProxy_New is also defined in dictobject.h
+        pub fn PyDictProxy_New(arg1: *mut PyObject) -> *mut PyObject;
+    }
     pub fn PyWrapper_New(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
 }