Rename directories to remove "wasm-bindgen-" prefix in sub-crates

crates/cli-support/src/wasm2es6js.rs

@@ -0,0 +1,214 @@
+extern crate base64;
+
+use std::collections::HashSet;
+
+use parity_wasm::elements::*;
+
+use super::Error;
+
+pub struct Config {
+    base64: bool,
+}
+
+pub struct Output {
+    module: Module,
+    base64: bool,
+}
+
+impl Config {
+    pub fn new() -> Config {
+        Config {
+            base64: false,
+        }
+    }
+
+    pub fn base64(&mut self, base64: bool) -> &mut Self {
+        self.base64 = base64;
+        self
+    }
+
+    pub fn generate(&mut self, wasm: &[u8]) -> Result<Output, Error> {
+        assert!(self.base64);
+        let module = deserialize_buffer(wasm).map_err(|e| {
+            ::Error(format!("{:?}", e))
+        })?;
+        Ok(Output {
+            module,
+            base64: self.base64,
+        })
+    }
+}
+
+impl Output {
+    pub fn typescript(&self) -> String {
+        let mut exports = format!("/* tslint:disable */\n");
+
+        if let Some(i) = self.module.export_section() {
+            let imported_functions = self.module.import_section()
+                .map(|m| m.functions() as u32)
+                .unwrap_or(0);
+            for entry in i.entries() {
+                let idx = match *entry.internal() {
+                    Internal::Function(i) => i - imported_functions,
+                    Internal::Memory(_) => {
+                        exports.push_str(&format!("
+                            export const {}: WebAssembly.Memory;
+                        ", entry.field()));
+                        continue
+                    }
+                    Internal::Table(_) => {
+                        continue
+                    }
+                    Internal::Global(_) => {
+                        continue
+                    }
+                };
+
+                let functions = self.module.function_section()
+                    .expect("failed to find function section");
+                let idx = functions.entries()[idx as usize].type_ref();
+
+                let types = self.module.type_section()
+                    .expect("failed to find type section");
+                let ty = match types.types()[idx as usize] {
+                    Type::Function(ref f) => f,
+                };
+                let mut args = String::new();
+                for (i, _) in ty.params().iter().enumerate() {
+                    if i > 0 {
+                        args.push_str(", ");
+                    }
+                    args.push((b'a' + (i as u8)) as char);
+                    args.push_str(": number");
+                }
+
+                exports.push_str(&format!("
+                    export function {name}({args}): {ret};
+                ",
+                    name = entry.field(),
+                    args = args,
+                    ret = if ty.return_type().is_some() { "number" } else { "void" },
+                ));
+            }
+        }
+
+        if self.base64 {
+            exports.push_str("export const booted: Promise<boolean>;");
+        }
+
+        return exports
+    }
+
+    pub fn js(self) -> String {
+        let mut js_imports = String::new();
+        let mut exports = String::new();
+        let mut imports = String::new();
+        let mut export_mem = false;
+
+        if let Some(i) = self.module.import_section() {
+            let mut set = HashSet::new();
+            for entry in i.entries() {
+                match *entry.external() {
+                    External::Function(_) => {}
+                    External::Table(_) => {
+                        panic!("wasm imports a table which isn't supported yet");
+                    }
+                    External::Memory(_) => {
+                        panic!("wasm imports memory which isn't supported yet");
+                    }
+                    External::Global(_) => {
+                        panic!("wasm imports globals which aren't supported yet");
+                    }
+                }
+
+                if !set.insert(entry.module()) {
+                    continue
+                }
+
+                let name = (b'a' + (set.len() as u8)) as char;
+                js_imports.push_str(&format!("import * as import_{} from '{}';",
+                                             name,
+                                             entry.module()));
+                imports.push_str(&format!("'{}': import_{}, ", entry.module(), name));
+            }
+        }
+
+        if let Some(i) = self.module.export_section() {
+            let imported_functions = self.module.import_section()
+                .map(|m| m.functions() as u32)
+                .unwrap_or(0);
+            for entry in i.entries() {
+                let idx = match *entry.internal() {
+                    Internal::Function(i) => i - imported_functions,
+                    Internal::Memory(_) => {
+                        export_mem = true;
+                        continue
+                    }
+                    Internal::Table(_) => {
+                        continue
+                    }
+                    Internal::Global(_) => {
+                        continue
+                    }
+                };
+
+                let functions = self.module.function_section()
+                    .expect("failed to find function section");
+                let idx = functions.entries()[idx as usize].type_ref();
+
+                let types = self.module.type_section()
+                    .expect("failed to find type section");
+                let ty = match types.types()[idx as usize] {
+                    Type::Function(ref f) => f,
+                };
+                let mut args = String::new();
+                for (i, _) in ty.params().iter().enumerate() {
+                    if i > 0 {
+                        args.push_str(", ");
+                    }
+                    args.push((b'a' + (i as u8)) as char);
+                }
+
+                exports.push_str(&format!("
+                    export function {name}({args}) {{
+                        {ret} wasm.exports.{name}({args});
+                    }}
+                ",
+                    name = entry.field(),
+                    args = args,
+                    ret = if ty.return_type().is_some() { "return" } else { "" },
+                ));
+            }
+        }
+
+        let wasm = serialize(self.module)
+            .expect("failed to serialize");
+
+        format!("
+            {js_imports}
+            let wasm;
+            let bytes;
+            const base64 = \"{base64}\";
+            if (typeof Buffer === 'undefined') {{
+                bytes = Uint8Array.from(atob(base64), c => c.charCodeAt(0));
+            }} else {{
+                bytes = Buffer.from(base64, 'base64');
+            }}
+            {mem_export}
+            export const booted = WebAssembly.instantiate(bytes, {{ {imports} }})
+                .then(obj => {{
+                    wasm = obj.instance;
+                    {memory}
+                }});
+
+            {exports}
+        ",
+            base64 = base64::encode(&wasm),
+            js_imports = js_imports,
+            imports = imports,
+            exports = exports,
+            mem_export = if export_mem { "export let memory;" } else { "" },
+            memory = if export_mem { "memory = wasm.exports.memory;" } else { "" },
+        )
+    }
+}