Revert "Refactor dispatch handling (#2452)"

Due to performance regression:
https://github.com/denoland/deno/commit/dc60fe9f300043f191286ef804a365e16e455f87#commitcomment-33943711

This reverts commit dc60fe9f300043f191286ef804a365e16e455f87.

2 files changed, 52 insertions, 59 deletions

diff --git a/js/dispatch.ts b/js/dispatch.ts
index 36f97363f..0c6e70709 100644
--- a/js/dispatch.ts
+++ b/js/dispatch.ts
@@ -5,30 +5,36 @@ import * as msg from "gen/cli/msg_generated";
 import * as errors from "./errors";
 import * as util from "./util";
 import {
+  nextPromiseId,
   recordFromBufMinimal,
   handleAsyncMsgFromRustMinimal
 } from "./dispatch_minimal";
 
 const promiseTable = new Map<number, util.Resolvable<msg.Base>>();
 
-function flatbufferRecordFromBuf(buf: Uint8Array): msg.Base {
+interface FlatbufferRecord {
+  promiseId: number;
+  base: msg.Base;
+}
+
+function flatbufferRecordFromBuf(buf: Uint8Array): FlatbufferRecord {
   const bb = new flatbuffers.ByteBuffer(buf);
   const base = msg.Base.getRootAsBase(bb);
-  return base;
+  return {
+    promiseId: base.cmdId(),
+    base
+  };
 }
 
-export function handleAsyncMsgFromRust(
-  promiseId: number,
-  ui8: Uint8Array
-): void {
+export function handleAsyncMsgFromRust(ui8: Uint8Array): void {
   const buf32 = new Int32Array(ui8.buffer, ui8.byteOffset, ui8.byteLength / 4);
   const recordMin = recordFromBufMinimal(buf32);
   if (recordMin) {
     // Fast and new
-    handleAsyncMsgFromRustMinimal(promiseId, ui8, recordMin);
+    handleAsyncMsgFromRustMinimal(ui8, recordMin);
   } else {
     // Legacy
-    let base = flatbufferRecordFromBuf(ui8);
+    let { promiseId, base } = flatbufferRecordFromBuf(ui8);
     const promise = promiseTable.get(promiseId);
     util.assert(promise != null, `Expecting promise in table. ${promiseId}`);
     promiseTable.delete(promiseId);
@@ -50,26 +56,14 @@ function sendInternal(
   innerType: msg.Any,
   inner: flatbuffers.Offset,
   zeroCopy: undefined | ArrayBufferView,
-  isSync: true
-): Uint8Array | null;
-function sendInternal(
-  builder: flatbuffers.Builder,
-  innerType: msg.Any,
-  inner: flatbuffers.Offset,
-  zeroCopy: undefined | ArrayBufferView,
-  isSync: false
-): Promise<msg.Base>;
-function sendInternal(
-  builder: flatbuffers.Builder,
-  innerType: msg.Any,
-  inner: flatbuffers.Offset,
-  zeroCopy: undefined | ArrayBufferView,
-  isSync: boolean
-): Promise<msg.Base> | Uint8Array | null {
+  sync = true
+): [number, null | Uint8Array] {
+  const cmdId = nextPromiseId();
   msg.Base.startBase(builder);
-  msg.Base.addSync(builder, isSync);
   msg.Base.addInner(builder, inner);
   msg.Base.addInnerType(builder, innerType);
+  msg.Base.addSync(builder, sync);
+  msg.Base.addCmdId(builder, cmdId);
   builder.finish(msg.Base.endBase(builder));
 
   const control = builder.asUint8Array();
@@ -80,25 +74,7 @@ function sendInternal(
   );
 
   builder.inUse = false;
-
-  if (typeof response === "number") {
-    const promise = util.createResolvable<msg.Base>();
-    promiseTable.set(response, promise);
-    util.assert(!isSync);
-    return promise;
-  } else {
-    if (!isSync) {
-      util.assert(response !== null);
-      const base = flatbufferRecordFromBuf(response as Uint8Array);
-      const err = errors.maybeError(base);
-      if (err != null) {
-        return Promise.reject(err);
-      } else {
-        return Promise.resolve(base);
-      }
-    }
-    return response;
-  }
+  return [cmdId, response];
 }
 
 // @internal
@@ -108,7 +84,16 @@ export function sendAsync(
   inner: flatbuffers.Offset,
   data?: ArrayBufferView
 ): Promise<msg.Base> {
-  const promise = sendInternal(builder, innerType, inner, data, false);
+  const [cmdId, response] = sendInternal(
+    builder,
+    innerType,
+    inner,
+    data,
+    false
+  );
+  util.assert(response == null); // null indicates async.
+  const promise = util.createResolvable<msg.Base>();
+  promiseTable.set(cmdId, promise);
   return promise;
 }
 
@@ -119,8 +104,10 @@ export function sendSync(
   inner: flatbuffers.Offset,
   data?: ArrayBufferView
 ): null | msg.Base {
-  const response = sendInternal(builder, innerType, inner, data, true);
-  if (response == null || response.length === 0) {
+  const [cmdId, response] = sendInternal(builder, innerType, inner, data, true);
+  util.assert(cmdId >= 0);
+  util.assert(response != null); // null indicates async.
+  if (response!.length === 0) {
     return null;
   } else {
     const bb = new flatbuffers.ByteBuffer(response!);
diff --git a/js/dispatch_minimal.ts b/js/dispatch_minimal.ts
index bf9065f56..17d328110 100644
--- a/js/dispatch_minimal.ts
+++ b/js/dispatch_minimal.ts
@@ -5,8 +5,14 @@ import { core } from "./core";
 
 const DISPATCH_MINIMAL_TOKEN = 0xcafe;
 const promiseTableMin = new Map<number, util.Resolvable<number>>();
+let _nextPromiseId = 0;
+
+export function nextPromiseId(): number {
+  return _nextPromiseId++;
+}
 
 export interface RecordMinimal {
+  promiseId: number;
   opId: number;
   arg: number;
   result: number;
@@ -22,9 +28,10 @@ export function hasMinimalToken(i32: Int32Array): boolean {
 export function recordFromBufMinimal(buf32: Int32Array): null | RecordMinimal {
   if (hasMinimalToken(buf32)) {
     return {
-      opId: buf32[1],
-      arg: buf32[2],
-      result: buf32[3]
+      promiseId: buf32[1],
+      opId: buf32[2],
+      arg: buf32[3],
+      result: buf32[4]
     };
   }
   return null;
@@ -39,13 +46,12 @@ const scratchBytes = new Uint8Array(
 util.assert(scratchBytes.byteLength === scratch32.length * 4);
 
 export function handleAsyncMsgFromRustMinimal(
-  promiseId: number,
   ui8: Uint8Array,
   record: RecordMinimal
 ): void {
   // Fast and new
   util.log("minimal handleAsyncMsgFromRust ", ui8.length);
-  const { result } = record;
+  const { promiseId, result } = record;
   const promise = promiseTableMin.get(promiseId);
   promiseTableMin.delete(promiseId);
   promise!.resolve(result);
@@ -56,16 +62,16 @@ export function sendAsyncMinimal(
   arg: number,
   zeroCopy: Uint8Array
 ): Promise<number> {
-  scratch32[0] = DISPATCH_MINIMAL_TOKEN;
-  scratch32[1] = opId;
-  scratch32[2] = arg;
+  const promiseId = nextPromiseId(); // AKA cmdId
 
-  const promiseId = core.dispatch(scratchBytes, zeroCopy);
-
-  util.assert(typeof promiseId == "number");
+  scratch32[0] = DISPATCH_MINIMAL_TOKEN;
+  scratch32[1] = promiseId;
+  scratch32[2] = opId;
+  scratch32[3] = arg;
 
   const promise = util.createResolvable<number>();
-  promiseTableMin.set(promiseId as number, promise);
+  promiseTableMin.set(promiseId, promise);
 
+  core.dispatch(scratchBytes, zeroCopy);
   return promise;
 }