Update to latest Walrus

Cargo.toml

@@ -23,10 +23,10 @@ path = "src/bin/wasm-snip.rs"
 required-features = ["exe"]
 
 [dependencies]
-failure = "0.1.5"
-walrus = { version = "0.12.0", features = ["parallel"] }
+walrus = { version = "0.23.2", features = ["parallel"] }
 regex = "1.3.1"
 rayon = "1.2.0"
+anyhow = "1.0"
 
 [dependencies.clap]
 optional = true

src/bin/wasm-snip.rs

@@ -1,20 +1,21 @@
-use failure::ResultExt;
 use std::fs;
 use std::io::{self, Write};
 use std::process;
 
+use anyhow::Context;
+
 fn main() {
     if let Err(e) = try_main() {
         eprintln!("error: {}", e);
-        for c in e.iter_chain().skip(1) {
+        for c in e.chain().skip(1) {
             eprintln!("  caused by {}", c);
         }
         eprintln!("{}", e.backtrace());
         process::exit(1)
     }
 }
 
-fn try_main() -> Result<(), failure::Error> {
+fn try_main() -> Result<(), anyhow::Error> {
     let matches = parse_args();
 
     let mut opts = wasm_snip::Options::default();
@@ -43,15 +44,15 @@ fn try_main() -> Result<(), failure::Error> {
 
     let config = walrus_config_from_options(&opts);
     let path = matches.value_of("input").unwrap();
-    let buf = fs::read(&path).with_context(|_| format!("failed to read file {}", path))?;
+    let buf = fs::read(&path).with_context(|| format!("failed to read file {}", path))?;
     let mut module = config.parse(&buf)?;
 
     wasm_snip::snip(&mut module, opts).context("failed to snip functions from wasm module")?;
 
     if let Some(output) = matches.value_of("output") {
         module
             .emit_wasm_file(output)
-            .with_context(|_| format!("failed to emit snipped wasm to {}", output))?;
+            .with_context(|| format!("failed to emit snipped wasm to {}", output))?;
     } else {
         let wasm = module.emit_wasm();
         let stdout = io::stdout();

src/lib.rs

@@ -105,7 +105,7 @@ dual licensed as above, without any additional terms or conditions.
 #![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
 
-use failure::ResultExt;
+use anyhow::Context;
 use rayon::prelude::*;
 use std::collections::HashMap;
 use std::collections::HashSet;
@@ -152,7 +152,7 @@ pub struct Options {
 }
 
 /// Snip the functions from the input file described by the options.
-pub fn snip(module: &mut walrus::Module, options: Options) -> Result<(), failure::Error> {
+pub fn snip(module: &mut walrus::Module, options: Options) -> Result<(), anyhow::Error> {
     if !options.skip_producers_section {
         module
             .producers
@@ -173,7 +173,7 @@ pub fn snip(module: &mut walrus::Module, options: Options) -> Result<(), failure
     Ok(())
 }
 
-fn build_regex_set(mut options: Options) -> Result<regex::RegexSet, failure::Error> {
+fn build_regex_set(mut options: Options) -> Result<regex::RegexSet, anyhow::Error> {
     // Snip the Rust `fmt` code, if requested.
     if options.snip_rust_fmt_code {
         // Mangled symbols.
@@ -253,7 +253,7 @@ fn replace_calls_with_unreachable(
     }
 
     impl VisitorMut for Replacer<'_> {
-        fn visit_instr_mut(&mut self, instr: &mut walrus::ir::Instr) {
+        fn visit_instr_mut(&mut self, instr: &mut walrus::ir::Instr, _: &mut walrus::InstrLocId) {
             if self.should_snip_call(instr) {
                 *instr = walrus::ir::Unreachable {}.into();
             }
@@ -319,31 +319,48 @@ fn snip_table_elements(module: &mut walrus::Module, to_snip: &HashSet<walrus::Fu
     };
 
     for t in module.tables.iter_mut() {
-        if let walrus::TableKind::Function(ref mut ft) = t.kind {
+        if matches!(t.element_ty, walrus::RefType::Funcref) {
             let types = &mut module.types;
             let locals = &mut module.locals;
             let funcs = &mut module.funcs;
-
-            ft.elements
-                .iter_mut()
-                .flat_map(|el| el)
-                .filter(|f| to_snip.contains(f))
-                .for_each(|el| {
-                    let ty = funcs.get(*el).ty();
-                    *el = *unreachable_funcs
-                        .entry(ty)
-                        .or_insert_with(|| make_unreachable_func(ty, types, locals, funcs));
-                });
-
-            ft.relative_elements
-                .iter_mut()
-                .flat_map(|(_, elems)| elems.iter_mut().filter(|f| to_snip.contains(f)))
-                .for_each(|el| {
-                    let ty = funcs.get(*el).ty();
-                    *el = *unreachable_funcs
-                        .entry(ty)
-                        .or_insert_with(|| make_unreachable_func(ty, types, locals, funcs));
-                });
+            let elements = &mut module.elements;
+
+            for segment in &t.elem_segments {
+                let elements = elements.get_mut(*segment);
+                match &mut elements.items {
+                    walrus::ElementItems::Functions(fs) => {
+                        fs.iter_mut()
+                            .filter(|f| to_snip.contains(f))
+                            .for_each(|el| {
+                                let ty = funcs.get(*el).ty();
+                                *el = *unreachable_funcs.entry(ty).or_insert_with(|| {
+                                    make_unreachable_func(ty, types, locals, funcs)
+                                });
+                            });
+                    }
+                    walrus::ElementItems::Expressions(walrus::RefType::Funcref, const_exprs) => {
+                        const_exprs
+                            .iter_mut()
+                            .filter_map(|f| {
+                                if let walrus::ConstExpr::RefFunc(f) = f {
+                                    Some(f)
+                                } else {
+                                    None
+                                }
+                            })
+                            .filter(|f| to_snip.contains(f))
+                            .for_each(|el| {
+                                let ty = funcs.get(*el).ty();
+                                *el = *unreachable_funcs.entry(ty).or_insert_with(|| {
+                                    make_unreachable_func(ty, types, locals, funcs)
+                                });
+                            });
+                    }
+                    walrus::ElementItems::Expressions(..) => {
+                        panic!("funcref table should only have elements of type functions")
+                    }
+                }
+            }
         }
     }
 }