Remove new() from CheckFloat, Repack and Snip

Author: axic

chisel/src/driver.rs

@@ -17,7 +17,7 @@ use libchisel::{
     checkfloat::CheckFloat, checkstartfunc::CheckStartFunc, deployer::Deployer,
     dropsection::DropSection, remapimports::RemapImports, remapstart::RemapStart, repack::Repack,
     snip::Snip, trimexports::TrimExports, trimstartfunc::TrimStartFunc,
-    verifyexports::VerifyExports, verifyimports::VerifyImports, Module, ModulePreset,
+    verifyexports::VerifyExports, verifyimports::VerifyImports, ChiselModule, Module, ModulePreset,
     ModuleTranslator, ModuleValidator,
 };
 
@@ -220,7 +220,7 @@ impl ChiselDriver {
     ) -> Result<ModuleResult, DriverError> {
         let result = match name.as_str() {
             "checkfloat" => {
-                let checkfloat = CheckFloat::new();
+                let checkfloat = CheckFloat::with_defaults().expect("Should not fail");
                 let module_result = checkfloat.validate(wasm);
                 ModuleResult::Validator(name, module_result)
             }
@@ -306,7 +306,7 @@ impl ChiselDriver {
                 ModuleResult::Translator(name, module_result)
             }
             "repack" => {
-                let repack = Repack::new();
+                let repack = Repack::with_defaults().expect("Should not fail");
                 let module_result = repack.translate(wasm).expect("No failure cases");
 
                 let did_mutate = if let Some(new_wasm) = module_result {
@@ -319,7 +319,7 @@ impl ChiselDriver {
                 ModuleResult::Translator(name, Ok(did_mutate))
             }
             "snip" => {
-                let snip = Snip::new();
+                let snip = Snip::with_defaults().expect("Should not fail");
                 let module_result = match snip.translate(wasm) {
                     Ok(result) => result,
                     Err(e) => {

libchisel/src/checkfloat.rs

@@ -31,12 +31,6 @@ impl<'a> ChiselModule<'a> for CheckFloat {
     }
 }
 
-impl CheckFloat {
-    pub fn new() -> Self {
-        CheckFloat {}
-    }
-}
-
 impl ModuleValidator for CheckFloat {
     // NOTE: this will not check for SIMD instructions.
     fn validate(&self, module: &Module) -> Result<bool, ModuleError> {
@@ -147,7 +141,7 @@ mod tests {
             0x00, 0x00, 0x0a, 0x09, 0x01, 0x07, 0x00, 0x20, 0x00, 0x20, 0x01, 0x6a, 0x0b,
         ];
         let module = Module::from_bytes(&wasm).unwrap();
-        let checker = CheckFloat::new();
+        let checker = CheckFloat::with_defaults().unwrap();
         let result = checker.validate(&module).unwrap();
         assert_eq!(true, result);
     }
@@ -167,7 +161,7 @@ mod tests {
             0x00, 0x00, 0x0a, 0x09, 0x01, 0x07, 0x00, 0x20, 0x00, 0x20, 0x01, 0x92, 0x0b,
         ];
         let module = Module::from_bytes(&wasm).unwrap();
-        let checker = CheckFloat::new();
+        let checker = CheckFloat::with_defaults().unwrap();
         let result = checker.validate(&module).unwrap();
         assert_eq!(false, result);
     }
@@ -187,15 +181,15 @@ mod tests {
             0x00, 0x00, 0x0a, 0x09, 0x01, 0x07, 0x00, 0x20, 0x00, 0x20, 0x01, 0xa0, 0x0b,
         ];
         let module = Module::from_bytes(&wasm).unwrap();
-        let checker = CheckFloat::new();
+        let checker = CheckFloat::with_defaults().unwrap();
         let result = checker.validate(&module).unwrap();
         assert_eq!(false, result);
     }
 
     #[test]
     fn no_code_section() {
         let module = builder::module().build();
-        let checker = CheckFloat::new();
+        let checker = CheckFloat::with_defaults().unwrap();
         let result = checker.validate(&module);
         assert_eq!(true, result.is_err());
         assert_eq!(result.err().unwrap(), ModuleError::NotFound)

libchisel/src/repack.rs

@@ -7,12 +7,6 @@ use super::{ChiselModule, ModuleError, ModuleKind, ModuleTranslator};
 
 pub struct Repack;
 
-impl Repack {
-    pub fn new() -> Self {
-        Repack {}
-    }
-}
-
 impl<'a> ChiselModule<'a> for Repack {
     type ObjectReference = &'a dyn ModuleTranslator;
 
@@ -29,7 +23,7 @@ impl<'a> ChiselModule<'a> for Repack {
     }
 
     fn with_defaults() -> Result<Self, ModuleError> {
-        Ok(Repack::new())
+        Ok(Repack {})
     }
 
     fn with_config(_config: &HashMap<String, String>) -> Result<Self, ModuleError> {
@@ -62,7 +56,7 @@ mod tests {
     fn smoke_test() {
         let module = Module::default();
 
-        let repack = Repack::new();
+        let repack = Repack::with_defaults().unwrap();
         assert_eq!(module, repack.translate(&module).unwrap().unwrap());
     }
 
@@ -87,7 +81,7 @@ mod tests {
             .build()
             .build();
 
-        let repack = Repack::new();
+        let repack = Repack::with_defaults().unwrap();
         assert_eq!(module, repack.translate(&module).unwrap().unwrap());
     }
 
@@ -117,7 +111,7 @@ mod tests {
             .sections_mut()
             .push(parity_wasm::elements::Section::Custom(custom));
 
-        let repack = Repack::new();
+        let repack = Repack::with_defaults().unwrap();
         assert_ne!(module, repack.translate(&module).unwrap().unwrap());
     }
 
@@ -135,7 +129,7 @@ mod tests {
             .parse_names()
             .expect("parsing the names section failed");
         assert_eq!(module.names_section().is_some(), true);
-        let repack = Repack::new();
+        let repack = Repack::with_defaults().unwrap();
         // Repack drops names section too.
         let output = repack.translate(&module).unwrap().unwrap();
         assert_eq!(output.has_names_section(), false);

libchisel/src/snip.rs

@@ -16,17 +16,6 @@ fn check_bool_option(config: &HashMap<String, String>, option: &str, default: bo
 #[derive(Clone)]
 pub struct Snip(wasm_snip::Options);
 
-impl Snip {
-    pub fn new() -> Self {
-        let mut options = wasm_snip::Options::default();
-        // TODO: expose these as options
-        options.snip_rust_fmt_code = true;
-        options.snip_rust_panicking_code = true;
-        options.skip_producers_section = true;
-        Snip { 0: options }
-    }
-}
-
 impl<'a> ChiselModule<'a> for Snip {
     type ObjectReference = &'a dyn ModuleTranslator;
 
@@ -43,7 +32,12 @@ impl<'a> ChiselModule<'a> for Snip {
     }
 
     fn with_defaults() -> Result<Self, ModuleError> {
-        Ok(Snip::new())
+        let mut options = wasm_snip::Options::default();
+        // TODO: expose these as options
+        options.snip_rust_fmt_code = true;
+        options.snip_rust_panicking_code = true;
+        options.skip_producers_section = true;
+        Ok(Snip { 0: options })
     }
 
     fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError> {
@@ -112,7 +106,7 @@ mod tests {
         .unwrap();
 
         let module = Module::from_bytes(&wasm).unwrap();
-        let module = Snip::new().translate(&module);
+        let module = Snip::with_defaults().unwrap().translate(&module);
         let module = module
             .expect("translation to be succesful")
             .expect("new module to be returned");

libchisel/src/trimexports.rs

@@ -31,7 +31,9 @@ impl<'a> ChiselModule<'a> for TrimExports {
     }
 
     fn with_defaults() -> Result<Self, ModuleError> {
-        Ok(TrimExports::new())
+        Ok(TrimExports {
+            whitelist: ExportWhitelist::new(),
+        })
     }
 
     fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError> {
@@ -87,13 +89,6 @@ impl ExportWhitelist {
 }
 
 impl TrimExports {
-    /// Constructs an empty `trimexports` context.
-    pub fn new() -> Self {
-        TrimExports {
-            whitelist: ExportWhitelist::new(),
-        }
-    }
-
     /// Iterates over the export section, if there is one, and removes
     /// unnecessary entries.
     fn trim_exports(&self, module: &mut Module) -> bool {