refactor: Rename JS entry functions (#3732)

cli/js/compiler.ts

@@ -32,7 +32,11 @@ import { fromTypeScriptDiagnostic } from "./diagnostics_util.ts";
 import * as os from "./os.ts";
 import { assert } from "./util.ts";
 import * as util from "./util.ts";
-import { postMessage, workerClose, workerMain } from "./worker_main.ts";
+import {
+  postMessage,
+  workerClose,
+  bootstrapWorkerRuntime
+} from "./worker_main.ts";
 
 const self = globalThis;
 
@@ -74,17 +78,19 @@ interface CompileResult {
 }
 
 // bootstrap the runtime environment, this gets called as the isolate is setup
-self.denoMain = function denoMain(compilerType?: string): void {
-  os.start(true, compilerType ?? "TS");
+self.bootstrapCompilerRuntime = function bootstrapCompilerRuntime(
+  compilerType: string
+): void {
+  os.start(true, compilerType);
 };
 
 // bootstrap the worker environment, this gets called as the isolate is setup
-self.workerMain = workerMain;
+self.bootstrapWorkerRuntime = bootstrapWorkerRuntime;
 
 // provide the "main" function that will be called by the privileged side when
 // lazy instantiating the compiler web worker
-self.compilerMain = function compilerMain(): void {
-  // workerMain should have already been called since a compiler is a worker.
+self.bootstrapTsCompiler = function tsCompilerMain(): void {
+  // bootstrapWorkerRuntime should have already been called since a compiler is a worker.
   self.onmessage = async ({
     data: request
   }: {
@@ -297,8 +303,8 @@ self.compilerMain = function compilerMain(): void {
   };
 };
 
-self.wasmCompilerMain = function wasmCompilerMain(): void {
-  // workerMain should have already been called since a compiler is a worker.
+self.bootstrapWasmCompiler = function wasmCompilerMain(): void {
+  // bootstrapWorkerRuntime should have already been called since a compiler is a worker.
   self.onmessage = async ({
     data: binary
   }: {

cli/js/globals.ts

@@ -111,12 +111,13 @@ declare global {
     callback: (event: domTypes.Event) => void | null,
     options?: boolean | domTypes.AddEventListenerOptions | undefined
   ) => void;
-  var compilerMain: (() => void) | undefined;
+  var bootstrapTsCompiler: (() => void) | undefined;
   var console: consoleTypes.Console;
   var Deno: {
     core: DenoCore;
   };
-  var denoMain: (() => void) | undefined;
+  var bootstrapCompilerRuntime: ((compilerType: string) => void) | undefined;
+  var bootstrapMainRuntime: (() => void) | undefined;
   var location: domTypes.Location;
   var onerror:
     | ((
@@ -132,8 +133,8 @@ declare global {
   var onmessage: ((e: { data: any }) => Promise<void> | void) | undefined;
   var onunload: ((e: domTypes.Event) => void) | undefined;
   var queueMicrotask: (callback: () => void) => void;
-  var wasmCompilerMain: (() => void) | undefined;
-  var workerMain: (() => Promise<void> | void) | undefined;
+  var bootstrapWasmCompiler: (() => void) | undefined;
+  var bootstrapWorkerRuntime: (() => Promise<void> | void) | undefined;
   /* eslint-enable */
 }
 
@@ -198,7 +199,7 @@ const globalProperties = {
   onmessage: writable(workerRuntime.onmessage),
   onerror: writable(workerRuntime.onerror),
 
-  workerMain: nonEnumerable(workerRuntime.workerMain),
+  bootstrapWorkerRuntime: nonEnumerable(workerRuntime.bootstrapWorkerRuntime),
   workerClose: nonEnumerable(workerRuntime.workerClose),
   postMessage: writable(workerRuntime.postMessage),
   Worker: nonEnumerable(workers.WorkerImpl),

cli/js/lib.deno_runtime.d.ts

@@ -2175,7 +2175,7 @@ declare interface Window {
   performance: __performanceUtil.Performance;
   onmessage: (e: { data: any }) => void;
   onerror: undefined | typeof onerror;
-  workerMain: typeof __workerMain.workerMain;
+  bootstrapWorkerRuntime: typeof __workerMain.bootstrapWorkerRuntime;
   workerClose: typeof __workerMain.workerClose;
   postMessage: typeof __workerMain.postMessage;
   Worker: typeof __workers.WorkerImpl;
@@ -2234,7 +2234,7 @@ declare let onerror:
       e: Event
     ) => boolean | void)
   | undefined;
-declare const workerMain: typeof __workerMain.workerMain;
+declare const bootstrapWorkerRuntime: typeof __workerMain.bootstrapWorkerRuntime;
 declare const workerClose: typeof __workerMain.workerClose;
 declare const postMessage: typeof __workerMain.postMessage;
 declare const Worker: typeof __workers.WorkerImpl;
@@ -3490,7 +3490,7 @@ declare namespace __workerMain {
   export function getMessage(): Promise<any>;
   export let isClosing: boolean;
   export function workerClose(): void;
-  export function workerMain(): Promise<void>;
+  export function bootstrapWorkerRuntime(): Promise<void>;
 }
 
 declare namespace __workers {

cli/js/main.ts

@@ -11,8 +11,8 @@ import { setLocation } from "./location.ts";
 import { setBuildInfo } from "./build.ts";
 import { setSignals } from "./process.ts";
 
-function denoMain(preserveDenoNamespace = true, name?: string): void {
-  const s = os.start(preserveDenoNamespace, name);
+function bootstrapMainRuntime(): void {
+  const s = os.start(true);
 
   setBuildInfo(s.os, s.arch);
   setSignals();
@@ -35,4 +35,4 @@ function denoMain(preserveDenoNamespace = true, name?: string): void {
     replLoop();
   }
 }
-globalThis["denoMain"] = denoMain;
+globalThis["bootstrapMainRuntime"] = bootstrapMainRuntime;

cli/js/os.ts

@@ -84,13 +84,10 @@ interface Start {
   arch: Arch;
 }
 
-// This function bootstraps an environment within Deno, it is shared both by
-// the runtime and the compiler environments.
-// @internal
-export function start(preserveDenoNamespace = true, source?: string): Start {
+// TODO(bartlomieju): temporary solution, must be fixed when moving
+// dispatches to separate crates
+export function initOps(): void {
   const ops = core.ops();
-  // TODO(bartlomieju): this is a prototype, we should come up with
-  // something a bit more sophisticated
   for (const [name, opId] of Object.entries(ops)) {
     const opName = `OP_${name.toUpperCase()}`;
     // Assign op ids to actual variables
@@ -98,6 +95,13 @@ export function start(preserveDenoNamespace = true, source?: string): Start {
     ((dispatch as unknown) as { [key: string]: number })[opName] = opId;
     core.setAsyncHandler(opId, dispatch.getAsyncHandler(opName));
   }
+}
+
+// This function bootstraps an environment within Deno, it is shared both by
+// the runtime and the compiler environments.
+// @internal
+export function start(preserveDenoNamespace = true, source?: string): Start {
+  initOps();
   // First we send an empty `Start` message to let the privileged side know we
   // are ready. The response should be a `StartRes` message containing the CLI
   // args and other info.

cli/js/worker_main.ts

@@ -1,10 +1,10 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { core } from "./core.ts";
 import * as dispatch from "./dispatch.ts";
 import { sendAsync, sendSync } from "./dispatch_json.ts";
 import { log } from "./util.ts";
 import { TextDecoder, TextEncoder } from "./text_encoding.ts";
+import { initOps } from "./os.ts";
 
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
@@ -44,24 +44,15 @@ export function workerClose(): void {
   isClosing = true;
 }
 
-export async function workerMain(): Promise<void> {
-  const ops = core.ops();
-  // TODO(bartlomieju): this is a prototype, we should come up with
-  // something a bit more sophisticated
-  for (const [name, opId] of Object.entries(ops)) {
-    const opName = `OP_${name.toUpperCase()}`;
-    // Assign op ids to actual variables
-    // TODO(ry) This type casting is gross and should be fixed.
-    ((dispatch as unknown) as { [key: string]: number })[opName] = opId;
-    core.setAsyncHandler(opId, dispatch.getAsyncHandler(opName));
-  }
+export async function bootstrapWorkerRuntime(): Promise<void> {
+  initOps();
 
-  log("workerMain");
+  log("bootstrapWorkerRuntime");
 
   while (!isClosing) {
     const data = await getMessage();
     if (data == null) {
-      log("workerMain got null message. quitting.");
+      log("bootstrapWorkerRuntime got null message. quitting.");
       break;
     }