BREAKING: Remove support for .wasm imports

cli/compilers/mod.rs

@@ -6,14 +6,12 @@ use futures::Future;
 mod compiler_worker;
 mod js;
 mod ts;
-mod wasm;
 
 pub use js::JsCompiler;
 pub use ts::runtime_compile;
 pub use ts::runtime_transpile;
 pub use ts::TargetLib;
 pub use ts::TsCompiler;
-pub use wasm::WasmCompiler;
 
 pub type CompilationResultFuture = dyn Future<Output = JsonResult>;
 

cli/compilers/ts.rs

@@ -688,8 +688,6 @@ impl TsCompiler {
   }
 }
 
-// TODO(bartlomieju): exactly same function is in `wasm.rs` - only difference
-// it created WasmCompiler instead of TsCompiler - deduplicate
 async fn execute_in_thread(
   global_state: GlobalState,
   req: Buf,

cli/global_state.rs

@@ -3,7 +3,6 @@ use crate::compilers::CompiledModule;
 use crate::compilers::JsCompiler;
 use crate::compilers::TargetLib;
 use crate::compilers::TsCompiler;
-use crate::compilers::WasmCompiler;
 use crate::deno_dir;
 use crate::file_fetcher::SourceFileFetcher;
 use crate::flags;
@@ -36,7 +35,6 @@ pub struct GlobalStateInner {
   pub file_fetcher: SourceFileFetcher,
   pub js_compiler: JsCompiler,
   pub ts_compiler: TsCompiler,
-  pub wasm_compiler: WasmCompiler,
   pub lockfile: Option<Mutex<Lockfile>>,
   pub compiler_starts: AtomicUsize,
   compile_lock: AsyncMutex<()>,
@@ -87,7 +85,6 @@ impl GlobalState {
       file_fetcher,
       ts_compiler,
       js_compiler: JsCompiler {},
-      wasm_compiler: WasmCompiler::default(),
       lockfile,
       compiler_starts: AtomicUsize::new(0),
       compile_lock: AsyncMutex::new(()),
@@ -116,12 +113,6 @@ impl GlobalState {
     let compile_lock = self.compile_lock.lock().await;
 
     let compiled_module = match out.media_type {
-      msg::MediaType::Json | msg::MediaType::Unknown => {
-        state1.js_compiler.compile(out).await
-      }
-      msg::MediaType::Wasm => {
-        state1.wasm_compiler.compile(state1.clone(), &out).await
-      }
       msg::MediaType::TypeScript
       | msg::MediaType::TSX
       | msg::MediaType::JSX => {
@@ -152,6 +143,7 @@ impl GlobalState {
           state1.js_compiler.compile(out).await
         }
       }
+      _ => state1.js_compiler.compile(out).await,
     }?;
     drop(compile_lock);
 

cli/js.rs

@@ -50,7 +50,7 @@ fn compiler_snapshot() {
   deno_core::js_check(isolate.execute(
     "<anon>",
     r#"
-    if (!(bootstrap.tsCompilerRuntime && bootstrap.wasmCompilerRuntime)) {
+    if (!(bootstrap.tsCompilerRuntime)) {
         throw Error("bad");
       }
       console.log(`ts version: ${ts.version}`);

cli/js/compiler.ts

@@ -4,10 +4,9 @@
 // This module is the entry point for "compiler" isolate, ie. the one
 // that is created when Deno needs to compile TS/WASM to JS.
 //
-// It provides a two functions that should be called by Rust:
+// It provides a single functions that should be called by Rust:
 //  - `bootstrapTsCompilerRuntime`
-//  - `bootstrapWasmCompilerRuntime`
-// Either of these functions must be called when creating isolate
+// This functions must be called when creating isolate
 // to properly setup runtime.
 
 // NOTE: this import has side effects!
@@ -22,7 +21,6 @@ import { sendAsync, sendSync } from "./ops/dispatch_json.ts";
 import { bootstrapWorkerRuntime } from "./runtime_worker.ts";
 import { assert, log } from "./util.ts";
 import * as util from "./util.ts";
-import { atob } from "./web/text_encoding.ts";
 import { TextDecoder, TextEncoder } from "./web/text_encoding.ts";
 import { core } from "./core.ts";
 
@@ -1123,16 +1121,6 @@ function commonPath(paths: string[], sep = "/"): string {
   return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
 }
 
-function base64ToUint8Array(data: string): Uint8Array {
-  const binString = atob(data);
-  const size = binString.length;
-  const bytes = new Uint8Array(size);
-  for (let i = 0; i < size; i++) {
-    bytes[i] = binString.charCodeAt(i);
-  }
-  return bytes;
-}
-
 let rootExports: string[] | undefined;
 
 function normalizeUrl(rootName: string): string {
@@ -1585,43 +1573,11 @@ async function tsCompilerOnMessage({
   // Currently Rust shuts down worker after single request
 }
 
-async function wasmCompilerOnMessage({
-  data: binary,
-}: {
-  data: string;
-}): Promise<void> {
-  const buffer = base64ToUint8Array(binary);
-  // @ts-ignore
-  const compiled = await WebAssembly.compile(buffer);
-
-  util.log(">>> WASM compile start");
-
-  const importList = Array.from(
-    // @ts-ignore
-    new Set(WebAssembly.Module.imports(compiled).map(({ module }) => module))
-  );
-  const exportList = Array.from(
-    // @ts-ignore
-    new Set(WebAssembly.Module.exports(compiled).map(({ name }) => name))
-  );
-
-  globalThis.postMessage({ importList, exportList });
-
-  util.log("<<< WASM compile end");
-
-  // Currently Rust shuts down worker after single request
-}
-
 function bootstrapTsCompilerRuntime(): void {
   bootstrapWorkerRuntime("TS", false);
   globalThis.onmessage = tsCompilerOnMessage;
 }
 
-function bootstrapWasmCompilerRuntime(): void {
-  bootstrapWorkerRuntime("WASM", false);
-  globalThis.onmessage = wasmCompilerOnMessage;
-}
-
 // Removes the `__proto__` for security reasons.  This intentionally makes
 // Deno non compliant with ECMA-262 Annex B.2.2.1
 //
@@ -1632,7 +1588,6 @@ Object.defineProperties(globalThis, {
   bootstrap: {
     value: {
       ...globalThis.bootstrap,
-      wasmCompilerRuntime: bootstrapWasmCompilerRuntime,
       tsCompilerRuntime: bootstrapTsCompilerRuntime,
     },
     configurable: true,

cli/js/globals.ts

@@ -147,7 +147,6 @@ declare global {
     workerRuntime: ((name: string) => Promise<void> | void) | undefined;
     // Assigned to `self` global - compiler
     tsCompilerRuntime: (() => void) | undefined;
-    wasmCompilerRuntime: (() => void) | undefined;
   };
 
   var onerror: