Add attempt for better module configuration

libchisel/src/binaryenopt.rs

@@ -1,6 +1,8 @@
+use std::collections::HashMap;
+
 use parity_wasm::elements::Module;
 
-use super::{ChiselModule, ModuleError, ModuleKind, ModulePreset, ModuleTranslator};
+use super::{ChiselModule, ModuleConfig, ModuleError, ModuleKind, ModulePreset, ModuleTranslator};
 
 // FIXME: change level names
 pub enum BinaryenOptimiser {
@@ -29,6 +31,20 @@ impl<'a> ChiselModule<'a> for BinaryenOptimiser {
     }
 }
 
+impl ModuleConfig for BinaryenOptimiser {
+    fn with_defaults() -> Result<Self, ModuleError> {
+        Ok(BinaryenOptimiser::O2)
+    }
+
+    fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError> {
+        if let Some(preset) = config.get("preset") {
+            BinaryenOptimiser::with_preset(preset)
+        } else {
+            Err(ModuleError::NotSupported)
+        }
+    }
+}
+
 impl ModulePreset for BinaryenOptimiser {
     fn with_preset(preset: &str) -> Result<Self, ModuleError> {
         match preset {

libchisel/src/checkfloat.rs

@@ -1,6 +1,8 @@
+use std::collections::HashMap;
+
 use parity_wasm::elements::{Instruction, Module};
 
-use super::{ChiselModule, ModuleError, ModuleKind, ModuleValidator};
+use super::{ChiselModule, ModuleConfig, ModuleError, ModuleKind, ModuleValidator};
 
 /// Struct on which ModuleValidator is implemented.
 pub struct CheckFloat {}
@@ -21,6 +23,16 @@ impl<'a> ChiselModule<'a> for CheckFloat {
     }
 }
 
+impl ModuleConfig for CheckFloat {
+    fn with_defaults() -> Result<Self, ModuleError> {
+        Ok(CheckFloat {})
+    }
+
+    fn with_config(_config: &HashMap<String, String>) -> Result<Self, ModuleError> {
+        Err(ModuleError::NotSupported)
+    }
+}
+
 impl CheckFloat {
     pub fn new() -> Self {
         CheckFloat {}

libchisel/src/checkstartfunc.rs

@@ -1,6 +1,8 @@
+use std::collections::HashMap;
+
 use parity_wasm::elements::Module;
 
-use super::{ChiselModule, ModuleError, ModuleKind, ModuleValidator};
+use super::{ChiselModule, ModuleConfig, ModuleError, ModuleKind, ModuleValidator};
 
 /// Struct on which ModuleValidator is implemented.
 pub struct CheckStartFunc {
@@ -31,6 +33,23 @@ impl<'a> ChiselModule<'a> for CheckStartFunc {
     }
 }
 
+impl ModuleConfig for CheckStartFunc {
+    fn with_defaults() -> Result<Self, ModuleError> {
+        Err(ModuleError::NotSupported)
+    }
+
+    fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError> {
+        let require_start = if let Some(value) = config.get("require_start") {
+            value == "true"
+        } else {
+            false
+        };
+        Ok(CheckStartFunc {
+            start_required: require_start,
+        })
+    }
+}
+
 impl ModuleValidator for CheckStartFunc {
     fn validate(&self, module: &Module) -> Result<bool, ModuleError> {
         Ok(module.start_section().is_some() == self.start_required)

libchisel/src/deployer.rs

@@ -1,7 +1,9 @@
+use std::collections::HashMap;
+
 use parity_wasm::builder;
 use parity_wasm::elements::{CustomSection, Module};
 
-use super::{ChiselModule, ModuleError, ModuleKind, ModulePreset, ModuleTranslator};
+use super::{ChiselModule, ModuleConfig, ModuleError, ModuleKind, ModulePreset, ModuleTranslator};
 
 /// Enum on which ModuleTranslator is implemented.
 pub enum Deployer {
@@ -25,6 +27,20 @@ impl<'a> ChiselModule<'a> for Deployer {
     }
 }
 
+impl ModuleConfig for Deployer {
+    fn with_defaults() -> Result<Self, ModuleError> {
+        Err(ModuleError::NotSupported)
+    }
+
+    fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError> {
+        if let Some(preset) = config.get("preset") {
+            Deployer::with_preset(preset)
+        } else {
+            Err(ModuleError::NotSupported)
+        }
+    }
+}
+
 impl ModulePreset for Deployer {
     fn with_preset(preset: &str) -> Result<Self, ModuleError> {
         match preset {

libchisel/src/dropsection.rs

@@ -1,8 +1,12 @@
+use std::collections::HashMap;
+use std::error::Error;
+
 use parity_wasm::elements::{Module, Section};
 
-use super::{ChiselModule, ModuleError, ModuleKind, ModuleTranslator};
+use super::{ChiselModule, ModuleConfig, ModuleError, ModuleKind, ModuleTranslator};
 
 /// Enum on which ModuleTranslator is implemented.
+#[derive(Debug)]
 pub enum DropSection {
     NamesSection,
     /// Name of the custom section.
@@ -29,6 +33,58 @@ impl<'a> ChiselModule<'a> for DropSection {
     }
 }
 
+impl From<std::num::ParseIntError> for ModuleError {
+    fn from(error: std::num::ParseIntError) -> Self {
+        ModuleError::Custom(error.description().to_string())
+    }
+}
+
+impl ModuleConfig for DropSection {
+    fn with_defaults() -> Result<Self, ModuleError> {
+        Err(ModuleError::NotSupported)
+    }
+
+    fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError> {
+        // Query all possible modes
+        let modes: [(&'static str, Option<&String>); 4] = [
+            ("names", config.get("names".into())),
+            ("custom_by_name", config.get("custom_by_name".into())),
+            ("custom_by_index", config.get("custom_by_index".into())),
+            ("unknown_by_index", config.get("unknown_by_index".into())),
+        ];
+
+        // Filter out modes which were provided.
+        let mut matches: Vec<(&'static str, &String)> = modes
+            .iter()
+            .filter_map(|(k, v)| {
+                if let Some(v) = v {
+                    Some((*k, *v))
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        // Reject multiple modes
+        if matches.len() != 1 {
+            return Err(ModuleError::Custom(
+                "Only one mode allowed at a time".to_string(),
+            ));
+        }
+
+        let (mode, val) = matches.pop().expect("Verified that one match is present");
+        match mode {
+            "names" => Ok(DropSection::NamesSection),
+            "custom_by_name" => Ok(DropSection::CustomSectionByName(val.clone())),
+            "custom_by_index" => Ok(DropSection::CustomSectionByIndex(str::parse::<usize>(val)?)),
+            "unknown_by_index" => Ok(DropSection::UnknownSectionByIndex(str::parse::<usize>(
+                val,
+            )?)),
+            _ => panic!("Only one of the above was present in the array"),
+        }
+    }
+}
+
 // TODO: consider upstreaming this
 fn custom_section_index_for(module: &Module, name: &str) -> Option<usize> {
     module.sections().iter().position(|e| match e {
@@ -258,4 +314,17 @@ mod tests {
         assert!(custom_section_index_for(&module, "name").is_none());
         assert!(custom_section_index_for(&module1, "name").is_none());
     }
+
+    #[test]
+    fn with_config_multiple_modes() {
+        let mut conf = HashMap::new();
+        conf.insert("names".to_string(), "".to_string());
+        conf.insert("custom_by_name".to_string(), "name".to_string());
+
+        let module = DropSection::with_config(&conf);
+        assert_eq!(
+            module.unwrap_err(),
+            ModuleError::Custom("Only one mode allowed at a time".to_string())
+        );
+    }
 }

libchisel/src/lib.rs

@@ -1,5 +1,6 @@
 pub use parity_wasm::elements::Module;
 
+use std::collections::HashMap;
 use std::{error, fmt};
 
 pub mod imports;
@@ -71,6 +72,17 @@ pub trait ModulePreset {
         Self: std::marker::Sized;
 }
 
+// TODO: move this to be part of ChiselModule and retire ModulePreset
+pub trait ModuleConfig {
+    fn with_defaults() -> Result<Self, ModuleError>
+    where
+        Self: std::marker::Sized;
+
+    fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError>
+    where
+        Self: std::marker::Sized;
+}
+
 impl From<String> for ModuleError {
     fn from(error: String) -> Self {
         ModuleError::Custom(error)

libchisel/src/remapimports.rs

@@ -1,7 +1,10 @@
+use std::collections::HashMap;
+
 use parity_wasm::elements::{ImportEntry, ImportSection, Module};
 
 use super::{
-    imports::ImportList, ChiselModule, ModuleError, ModuleKind, ModulePreset, ModuleTranslator,
+    imports::ImportList, ChiselModule, ModuleConfig, ModuleError, ModuleKind, ModulePreset,
+    ModuleTranslator,
 };
 
 pub struct RemapImports<'a> {
@@ -29,6 +32,20 @@ impl<'a> ChiselModule<'a> for RemapImports<'a> {
     }
 }
 
+impl<'a> ModuleConfig for RemapImports<'a> {
+    fn with_defaults() -> Result<Self, ModuleError> {
+        Err(ModuleError::NotSupported)
+    }
+
+    fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError> {
+        if let Some(preset) = config.get("preset") {
+            RemapImports::with_preset(preset)
+        } else {
+            Err(ModuleError::NotSupported)
+        }
+    }
+}
+
 impl<'a> ModulePreset for RemapImports<'a> {
     fn with_preset(preset: &str) -> Result<Self, ModuleError> {
         let mut interface_set: Vec<ImportInterface> = Vec::new();

libchisel/src/remapstart.rs

@@ -1,6 +1,8 @@
+use std::collections::HashMap;
+
 use parity_wasm::elements::{ExportEntry, ExportSection, Internal, Module, Section};
 
-use super::{ChiselModule, ModuleError, ModuleKind, ModulePreset, ModuleTranslator};
+use super::{ChiselModule, ModuleConfig, ModuleError, ModuleKind, ModulePreset, ModuleTranslator};
 
 pub struct RemapStart;
 
@@ -30,6 +32,21 @@ impl<'a> ChiselModule<'a> for RemapStart {
     }
 }
 
+impl ModuleConfig for RemapStart {
+    fn with_defaults() -> Result<Self, ModuleError> {
+        Ok(RemapStart {})
+    }
+
+    // FIXME: drop this, no need for preset here
+    fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError> {
+        if let Some(preset) = config.get("preset") {
+            RemapStart::with_preset(preset)
+        } else {
+            Err(ModuleError::NotSupported)
+        }
+    }
+}
+
 impl ModuleTranslator for RemapStart {
     fn translate_inplace(&self, module: &mut Module) -> Result<bool, ModuleError> {
         Ok(remap_start(module))

libchisel/src/repack.rs

@@ -1,7 +1,9 @@
+use std::collections::HashMap;
+
 use parity_wasm::builder;
 use parity_wasm::elements::Module;
 
-use super::{ChiselModule, ModuleError, ModuleKind, ModuleTranslator};
+use super::{ChiselModule, ModuleConfig, ModuleError, ModuleKind, ModuleTranslator};
 
 pub struct Repack;
 
@@ -27,6 +29,16 @@ impl<'a> ChiselModule<'a> for Repack {
     }
 }
 
+impl ModuleConfig for Repack {
+    fn with_defaults() -> Result<Self, ModuleError> {
+        Ok(Repack::new())
+    }
+
+    fn with_config(_config: &HashMap<String, String>) -> Result<Self, ModuleError> {
+        Err(ModuleError::NotSupported)
+    }
+}
+
 impl ModuleTranslator for Repack {
     fn translate_inplace(&self, _module: &mut Module) -> Result<bool, ModuleError> {
         Err(ModuleError::NotSupported)

libchisel/src/snip.rs

@@ -1,6 +1,8 @@
+use std::collections::HashMap;
+
 use parity_wasm::elements::Module;
 
-use super::{ChiselModule, ModuleError, ModuleKind, ModuleTranslator};
+use super::{ChiselModule, ModuleConfig, ModuleError, ModuleKind, ModuleTranslator};
 
 #[derive(Clone)]
 pub struct Snip(wasm_snip::Options);
@@ -32,6 +34,30 @@ impl<'a> ChiselModule<'a> for Snip {
     }
 }
 
+// TODO: consider making this a generic helper?
+fn check_bool_option(config: &HashMap<String, String>, option: &str, default: bool) -> bool {
+    if let Some(value) = config.get(option) {
+        value == "true"
+    } else {
+        default
+    }
+}
+
+impl ModuleConfig for Snip {
+    fn with_defaults() -> Result<Self, ModuleError> {
+        Ok(Snip::new())
+    }
+
+    fn with_config(config: &HashMap<String, String>) -> Result<Self, ModuleError> {
+        let mut options = wasm_snip::Options::default();
+        options.snip_rust_fmt_code = check_bool_option(&config, "snip_rust_fmt_code", true);
+        options.snip_rust_panicking_code =
+            check_bool_option(&config, "snip_rust_panicking_code", true);
+        options.skip_producers_section = check_bool_option(&config, "skip_producers_section", true);
+        Ok(Snip { 0: options })
+    }
+}
+
 impl From<failure::Error> for ModuleError {
     fn from(error: failure::Error) -> Self {
         ModuleError::Custom(error.to_string())