Initial commit -- it works!

Author: fitzgen

Diff for: .gitattributes

@@ -0,0 +1 @@
+README.md -diff -merge

Diff for: .gitignore

@@ -0,0 +1,4 @@
+/tests/snipped.wasm
+/target/
+**/*.rs.bk
+Cargo.lock

Diff for: CONTRIBUTING.md

@@ -0,0 +1,63 @@
+# Contributing to `wasm-snip`
+
+Hi! We'd love to have your contributions! If you want help or mentorship, reach
+out to us in a GitHub issue, or ping `fitzgen`
+in [#rust on irc.mozilla.org](irc://irc.mozilla.org#rust) and introduce
+yourself.
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+
+- [Code of Conduct](#code-of-conduct)
+- [Building](#building)
+- [Testing](#testing)
+- [Automatic code formatting](#automatic-code-formatting)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Code of Conduct
+
+We abide by the [Rust Code of Conduct][coc] and ask that you do as well.
+
+[coc]: https://www.rust-lang.org/en-US/conduct.html
+
+## Building
+
+```
+$ cargo build
+```
+
+## Testing
+
+The tests require `cargo-readme` to be installed:
+
+```
+$ cargo install cargo-readme
+```
+
+To run all the tests:
+
+```
+$ cargo test
+```
+
+## Automatic code formatting
+
+We use [`rustfmt`](https://github.com/rust-lang-nursery/rustfmt) to enforce a
+consistent code style across the whole code base.
+
+You can install the latest version of `rustfmt` with this command:
+
+```
+$ rustup update nightly
+$ cargo install -f rustfmt-nightly
+```
+
+Ensure that `~/.cargo/bin` is on your path.
+
+Once that is taken care of, you can (re)format all code by running this command:
+
+```
+$ cargo fmt
+```

Diff for: Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+authors = ["Nick Fitzgerald <[email protected]>"]
+description = "Replace a wasm function with an `unreachable`."
+keywords = ["symbol", "wasm", "snip", "size", "profiling"]
+license = "Apache-2.0/MIT"
+name = "wasm-snip"
+readme = "./README.md"
+repository = "https://github.com/fitzgen/wasm-snip"
+version = "0.1.0"
+
+[[bin]]
+doc = false
+name = "wasm-snip"
+path = "src/bin/wasm-snip.rs"
+required-features = ["exe"]
+
+[dependencies]
+failure = "0.1.1"
+parity-wasm = "0.19.0"
+
+[dependencies.clap]
+optional = true
+version = "2.29.0"
+
+[features]
+default = ["exe"]
+exe = ["clap"]

Diff for: README.md

@@ -0,0 +1,74 @@
+# `wasm-snip`
+
+[![](https://docs.rs/wasm-snip/badge.svg)](https://docs.rs/wasm-snip/) [![](https://img.shields.io/crates/v/wasm-snip.svg)](https://crates.io/crates/wasm-snip) [![](https://img.shields.io/crates/d/wasm-snip.png)](https://crates.io/crates/wasm-snip) [![Build Status](https://travis-ci.org/fitzgen/wasm-snip.png?branch=master)](https://travis-ci.org/fitzgen/wasm-snip)
+
+`wasm-snip` replaces a WebAssembly function's body with a `unreachable`.
+
+Maybe you know that some function will never be called at runtime, but the
+compiler can't prove that at compile time? Snip it! Then run `wasm-gc`[0] again
+and all the functions it transitively called (which could also never be called
+at runtime) will get removed too.
+
+Very helpful when shrinking the size of WebAssembly binaries!
+
+This functionality relies on the "name" section being present in the `.wasm`
+file, so build with debug symbols.
+
+```toml
+[profile.release]
+debug = true
+```
+
+* [Executable](#executable)
+* [Library](#library)
+* [License](#license)
+* [Contributing](#contributing)
+
+### Executable
+
+To install the `wasm-snip` executable, run
+
+```
+$ cargo install wasm-snip
+```
+
+For information on using the `wasm-snip` executable, run
+
+```
+$ wasm-snip --help
+```
+
+### Library
+
+To use `wasm-snip` as a library, add this to your `Cargo.toml`:
+
+```toml
+[dependencies.wasm-snip]
+# Do not build the executable.
+default-features = false
+```
+
+See [docs.rs/wasm-snip][docs] for API documentation.
+
+[docs]: https://docs.rs/wasm-snip
+
+### License
+
+Licensed under either of
+
+ * [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+ * [MIT license](http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contributing
+
+See
+[CONTRIBUTING.md](https://github.com/fitzgen/wasm-snip/blob/master/CONTRIBUTING.md)
+for hacking.
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
+

Diff for: README.tpl

@@ -0,0 +1,3 @@
+# `{{crate}}`
+
+{{readme}}

Diff for: src/bin/wasm-snip.rs

@@ -0,0 +1,82 @@
+extern crate clap;
+extern crate failure;
+extern crate parity_wasm;
+extern crate wasm_snip;
+
+use parity_wasm::elements::{self, Serialize};
+use std::io;
+use std::path;
+use std::process;
+
+fn main() {
+    if let Err(e) = try_main() {
+        eprintln!("error: {}", e);
+        for c in e.causes().skip(1) {
+            eprintln!("  caused by {}", c);
+        }
+        eprintln!("{}", e.backtrace());
+        process::exit(1)
+    }
+}
+
+fn try_main() -> Result<(), failure::Error> {
+    let matches = parse_args();
+
+    let mut opts = wasm_snip::Options::default();
+    opts.input = path::PathBuf::from(matches.value_of("input").unwrap());
+    opts.functions = matches
+        .values_of("function")
+        .unwrap()
+        .map(|f| f.to_string())
+        .collect();
+
+    let module = wasm_snip::snip(opts)?;
+
+    if let Some(output) = matches.value_of("output") {
+        elements::serialize_to_file(output, module)?;
+    } else {
+        let stdout = io::stdout();
+        let mut stdout = stdout.lock();
+        module.serialize(&mut stdout)?;
+    }
+
+    Ok(())
+}
+
+fn parse_args() -> clap::ArgMatches<'static> {
+    clap::App::new(env!("CARGO_PKG_NAME"))
+        .version(env!("CARGO_PKG_VERSION"))
+        .author(env!("CARGO_PKG_AUTHORS"))
+        .about(env!("CARGO_PKG_DESCRIPTION"))
+        .long_about(
+            "
+`wasm-snip` replaces a WebAssembly function's body with an `unreachable`.
+
+Maybe you know that some function will never be called at runtime, but the
+compiler can't prove that at compile time? Snip it! Then run `wasm-gc`[0] again
+and all the functions it transitively called (which could also never be called
+at runtime) will get removed too.
+
+Very helpful when shrinking the size of WebAssembly binaries!
+",
+        )
+        .arg(
+            clap::Arg::with_name("output")
+                .short("o")
+                .long("output")
+                .takes_value(true)
+                .help("The path to write the output wasm file to. Defaults to stdout."),
+        )
+        .arg(
+            clap::Arg::with_name("input")
+                .required(true)
+                .help("The input wasm file containing the function(s) to snip."),
+        )
+        .arg(
+            clap::Arg::with_name("function")
+                .required(true)
+                .multiple(true)
+                .help("The function(s) to snip."),
+        )
+        .get_matches()
+}