namespace reorg: libdeno and DenoCore to Deno.core (#1998)

denoland · Mar 26, 2019 · c43cfed · c43cfed
1 parent ed2977d
commit c43cfed
Show file tree

Hide file tree

Showing 26 changed files with 178 additions and 146 deletions.
diff --git a/BUILD.gn b/BUILD.gn
@@ -82,7 +82,6 @@ ts_sources = [
   "js/globals.ts",
   "js/headers.ts",
   "js/io.ts",
-  "js/libdeno.ts",
   "js/lib.web_assembly.d.ts",
   "js/location.ts",
   "js/main.ts",

diff --git a/cli/ops.rs b/cli/ops.rs
@@ -69,9 +69,9 @@ fn empty_buf() -> Buf {
 }
 
 /// Processes raw messages from JavaScript.
-/// This functions invoked every time libdeno.send() is called.
-/// control corresponds to the first argument of libdeno.send().
-/// data corresponds to the second argument of libdeno.send().
+/// This functions invoked every time Deno.core.dispatch() is called.
+/// control corresponds to the first argument of Deno.core.dispatch().
+/// data corresponds to the second argument of Deno.core.dispatch().
 pub fn dispatch_all(
   sc: &IsolateStateContainer,
   control: &[u8],

diff --git a/core/core.d.ts b/core/core.d.ts
@@ -0,0 +1,25 @@
+// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
+
+// This file contains APIs that are introduced into the global namespace by
+// Deno core.  These are not intended to be used directly by runtime users of
+// Deno and therefore do not flow through to the runtime type library.
+
+declare interface MessageCallback {
+  (msg: Uint8Array): void;
+}
+
+declare interface DenoCore {
+  dispatch(
+    control: Uint8Array,
+    zeroCopy?: ArrayBufferView | null
+  ): Uint8Array | null;
+  setAsyncHandler(cb: MessageCallback): void;
+  sharedQueue: {
+    head(): number;
+    numRecords(): number;
+    size(): number;
+    push(buf: Uint8Array): boolean;
+    reset(): void;
+    shift(): Uint8Array | null;
+  };
+}
diff --git a/core/http_bench.js b/core/http_bench.js
@@ -42,7 +42,7 @@ function send(promiseId, opId, arg, zeroCopy = null) {
   scratch32[1] = opId;
   scratch32[2] = arg;
   scratch32[3] = -1;
-  return DenoCore.dispatch(scratchBytes, zeroCopy);
+  return Deno.core.dispatch(scratchBytes, zeroCopy);
 }
 
 /** Returns Promise<number> */
@@ -123,17 +123,17 @@ async function serve(rid) {
 }
 
 async function main() {
-  DenoCore.setAsyncHandler(handleAsyncMsgFromRust);
+  Deno.core.setAsyncHandler(handleAsyncMsgFromRust);
 
-  libdeno.print("http_bench.js start\n");
+  Deno.core.print("http_bench.js start\n");
 
   const listenerRid = listen();
-  libdeno.print(`listening http://127.0.0.1:4544/ rid = ${listenerRid}\n`);
+  Deno.core.print(`listening http://127.0.0.1:4544/ rid = ${listenerRid}\n`);
   while (true) {
     const rid = await accept(listenerRid);
-    // libdeno.print(`accepted ${rid}`);
+    // Deno.core.print(`accepted ${rid}`);
     if (rid < 0) {
-      libdeno.print(`accept error ${rid}`);
+      Deno.core.print(`accept error ${rid}`);
       return;
     }
     serve(rid);

diff --git a/core/isolate.rs b/core/isolate.rs
@@ -63,8 +63,8 @@ pub trait Behavior {
   /// Isolate is created.
   fn startup_data(&mut self) -> Option<StartupData>;
 
-  /// Called whenever libdeno.send() is called in JavaScript. zero_copy_buf
-  /// corresponds to the second argument of libdeno.send().
+  /// Called whenever Deno.core.send() is called in JavaScript. zero_copy_buf
+  /// corresponds to the second argument of Deno.core.send().
   fn dispatch(
     &mut self,
     control: &[u8],
@@ -77,7 +77,7 @@ pub trait Behavior {
 /// Tokio.  The Isolate future complete when there is an error or when all
 /// pending ops have completed.
 ///
-/// Ops are created in JavaScript by calling libdeno.send(), and in Rust by
+/// Ops are created in JavaScript by calling Deno.core.send(), and in Rust by
 /// implementing Behavior::dispatch. An Op corresponds exactly to a Promise in
 /// JavaScript.
 pub struct Isolate<B: Behavior> {
@@ -125,7 +125,7 @@ impl<B: Behavior> Isolate<B> {
         None => libdeno::deno_buf::empty(),
       },
       shared: shared.as_deno_buf(),
-      recv_cb: Self::pre_dispatch,
+      recv_cb: Self::predispatch,
     };
     let libdeno_isolate = unsafe { libdeno::deno_new(config) };
 
@@ -157,7 +157,7 @@ impl<B: Behavior> Isolate<B> {
     }
   }
 
-  /// Executes a bit of built-in JavaScript to provide Deno._sharedQueue.
+  /// Executes a bit of built-in JavaScript to provide Deno.sharedQueue.
   pub fn shared_init(&mut self) {
     if self.needs_init {
       self.needs_init = false;
@@ -167,7 +167,7 @@ impl<B: Behavior> Isolate<B> {
     }
   }
 
-  extern "C" fn pre_dispatch(
+  extern "C" fn predispatch(
     user_data: *mut c_void,
     control_argv0: deno_buf,
     zero_copy_buf: deno_buf,
@@ -178,12 +178,12 @@ impl<B: Behavior> Isolate<B> {
     let control_shared = isolate.shared.shift();
 
     let (is_sync, op) = if control_argv0.len() > 0 {
-      // The user called libdeno.send(control)
+      // The user called Deno.core.send(control)
       isolate
         .behavior
         .dispatch(control_argv0.as_ref(), zero_copy_buf)
     } else if let Some(c) = control_shared {
-      // The user called Deno._sharedQueue.push(control)
+      // The user called Deno.sharedQueue.push(control)
       isolate.behavior.dispatch(&c, zero_copy_buf)
     } else {
       // The sharedQueue is empty. The shouldn't happen usually, but it's also
@@ -199,7 +199,7 @@ impl<B: Behavior> Isolate<B> {
 
     if is_sync {
       let res_record = op.wait().unwrap();
-      // For sync messages, we always return the response via libdeno.send's
+      // For sync messages, we always return the response via Deno.core.send's
       // return value.
       // TODO(ry) check that if JSError thrown during respond(), that it will be
       // picked up.
@@ -614,15 +614,15 @@ mod tests {
   }
 
   #[test]
-  fn test_dispatch() {
+  fn testdispatch() {
     let mut isolate = TestBehavior::setup(TestBehaviorMode::AsyncImmediate);
     js_check(isolate.execute(
       "filename.js",
       r#"
         let control = new Uint8Array([42]);
-        libdeno.send(control);
+        Deno.core.send(control);
         async function main() {
-          libdeno.send(control);
+          Deno.core.send(control);
         }
         main();
         "#,
@@ -641,7 +641,7 @@ mod tests {
         import { b } from 'b.js'
         if (b() != 'b') throw Error();
         let control = new Uint8Array([42]);
-        libdeno.send(control);
+        Deno.core.send(control);
       "#,
       ).unwrap();
     assert_eq!(isolate.behavior.dispatch_count, 0);
@@ -685,7 +685,7 @@ mod tests {
       "setup2.js",
       r#"
         let nrecv = 0;
-        DenoCore.setAsyncHandler((buf) => {
+        Deno.core.setAsyncHandler((buf) => {
           nrecv++;
         });
         "#,
@@ -696,7 +696,7 @@ mod tests {
       r#"
         assert(nrecv == 0);
         let control = new Uint8Array([42]);
-        libdeno.send(control);
+        Deno.core.send(control);
         assert(nrecv == 0);
         "#,
     ));
@@ -707,7 +707,7 @@ mod tests {
       "check2.js",
       r#"
         assert(nrecv == 1);
-        libdeno.send(control);
+        Deno.core.send(control);
         assert(nrecv == 1);
         "#,
     ));
@@ -727,7 +727,7 @@ mod tests {
       "setup2.js",
       r#"
         let nrecv = 0;
-        DenoCore.setAsyncHandler((buf) => {
+        Deno.core.setAsyncHandler((buf) => {
           assert(buf.byteLength === 1);
           assert(buf[0] === 43);
           nrecv++;
@@ -740,12 +740,12 @@ mod tests {
       "send1.js",
       r#"
         let control = new Uint8Array([42]);
-        DenoCore.shared.push(control);
-        libdeno.send();
+        Deno.core.sharedQueue.push(control);
+        Deno.core.send();
         assert(nrecv === 0);
 
-        DenoCore.shared.push(control);
-        libdeno.send();
+        Deno.core.sharedQueue.push(control);
+        Deno.core.send();
         assert(nrecv === 0);
         "#,
     ));
@@ -832,10 +832,10 @@ mod tests {
       "overflow_req_sync.js",
       r#"
         let asyncRecv = 0;
-        DenoCore.setAsyncHandler((buf) => { asyncRecv++ });
+        Deno.core.setAsyncHandler((buf) => { asyncRecv++ });
         // Large message that will overflow the shared space.
         let control = new Uint8Array(100 * 1024 * 1024);
-        let response = DenoCore.dispatch(control);
+        let response = Deno.core.dispatch(control);
         assert(response instanceof Uint8Array);
         assert(response.length == 1);
         assert(response[0] == 43);
@@ -854,10 +854,10 @@ mod tests {
       "overflow_res_sync.js",
       r#"
         let asyncRecv = 0;
-        DenoCore.setAsyncHandler((buf) => { asyncRecv++ });
+        Deno.core.setAsyncHandler((buf) => { asyncRecv++ });
         // Large message that will overflow the shared space.
         let control = new Uint8Array([42]);
-        let response = DenoCore.dispatch(control);
+        let response = Deno.core.dispatch(control);
         assert(response instanceof Uint8Array);
         assert(response.length == 100 * 1024 * 1024);
         assert(response[0] == 99);
@@ -874,14 +874,14 @@ mod tests {
       "overflow_req_async.js",
       r#"
         let asyncRecv = 0;
-        DenoCore.setAsyncHandler((buf) => {
+        Deno.core.setAsyncHandler((buf) => {
           assert(buf.byteLength === 1);
           assert(buf[0] === 43);
           asyncRecv++;
         });
         // Large message that will overflow the shared space.
         let control = new Uint8Array(100 * 1024 * 1024);
-        let response = DenoCore.dispatch(control);
+        let response = Deno.core.dispatch(control);
         // Async messages always have null response.
         assert(response == null);
         assert(asyncRecv == 0);
@@ -901,14 +901,14 @@ mod tests {
       "overflow_res_async.js",
       r#"
         let asyncRecv = 0;
-        DenoCore.setAsyncHandler((buf) => {
+        Deno.core.setAsyncHandler((buf) => {
           assert(buf.byteLength === 100 * 1024 * 1024);
           assert(buf[0] === 4);
           asyncRecv++;
         });
         // Large message that will overflow the shared space.
         let control = new Uint8Array([42]);
-        let response = DenoCore.dispatch(control);
+        let response = Deno.core.dispatch(control);
         assert(response == null);
         assert(asyncRecv == 0);
         "#,
@@ -919,27 +919,27 @@ mod tests {
   }
 
   #[test]
-  fn overflow_res_multiple_dispatch_async() {
+  fn overflow_res_multipledispatch_async() {
     // TODO(ry) This test is quite slow due to memcpy-ing 100MB into JS. We
     // should optimize this.
     let mut isolate = TestBehavior::setup(TestBehaviorMode::OverflowResAsync);
     js_check(isolate.execute(
-      "overflow_res_multiple_dispatch_async.js",
+      "overflow_res_multipledispatch_async.js",
       r#"
         let asyncRecv = 0;
-        DenoCore.setAsyncHandler((buf) => {
+        Deno.core.setAsyncHandler((buf) => {
           assert(buf.byteLength === 100 * 1024 * 1024);
           assert(buf[0] === 4);
           asyncRecv++;
         });
         // Large message that will overflow the shared space.
         let control = new Uint8Array([42]);
-        let response = DenoCore.dispatch(control);
+        let response = Deno.core.dispatch(control);
         assert(response == null);
         assert(asyncRecv == 0);
         // Dispatch another message to verify that pending ops
         // are done even if shared space overflows
-        DenoCore.dispatch(control);
+        Deno.core.dispatch(control);
         "#,
     ));
     assert_eq!(isolate.behavior.dispatch_count, 2);