Add libdeno.builtinModules (#1463)

This is needed to support builtin modules like

    import { open } from "deno"

js/libdeno.ts

@@ -18,6 +18,8 @@ interface Libdeno {
 
   shared: ArrayBuffer;
 
+  builtinModules: { [s: string]: object };
+
   setGlobalErrorHandler: (
     handler: (
       message: string,

libdeno/binding.cc

@@ -323,6 +323,23 @@ void Send(const v8::FunctionCallbackInfo<v8::Value>& args) {
   }
 }
 
+v8::Local<v8::Object> DenoIsolate::GetBuiltinModules() {
+  v8::EscapableHandleScope handle_scope(isolate_);
+  if (builtin_modules_.IsEmpty()) {
+    builtin_modules_.Reset(isolate_, v8::Object::New(isolate_));
+  }
+  return handle_scope.Escape(builtin_modules_.Get(isolate_));
+}
+
+void BuiltinModules(v8::Local<v8::Name> property,
+                    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  v8::Isolate* isolate = info.GetIsolate();
+  DenoIsolate* d = FromIsolate(isolate);
+  DCHECK_EQ(d->isolate_, isolate);
+  v8::Locker locker(d->isolate_);
+  info.GetReturnValue().Set(d->GetBuiltinModules());
+}
+
 void Shared(v8::Local<v8::Name> property,
             const v8::PropertyCallbackInfo<v8::Value>& info) {
   v8::Isolate* isolate = info.GetIsolate();
@@ -408,6 +425,44 @@ v8::MaybeLocal<v8::Module> ResolveCallback(v8::Local<v8::Context> context,
   v8::EscapableHandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context);
 
+  v8::String::Utf8Value specifier_utf8val(isolate, specifier);
+  const char* specifier_cstr = ToCString(specifier_utf8val);
+
+  auto builtin_modules = d->GetBuiltinModules();
+  bool has_builtin = builtin_modules->Has(context, specifier).ToChecked();
+  if (has_builtin) {
+    auto val = builtin_modules->Get(context, specifier).ToLocalChecked();
+    CHECK(val->IsObject());
+    auto obj = val->ToObject(isolate);
+
+    // In order to export obj as a module, we must iterate over its properties
+    // and export them each individually.
+    // TODO Find a better way to do this.
+    std::string src = "let globalEval = eval\nlet g = globalEval('this');\n";
+    auto names = obj->GetOwnPropertyNames(context).ToLocalChecked();
+    for (uint32_t i = 0; i < names->Length(); i++) {
+      auto name = names->Get(context, i).ToLocalChecked();
+      v8::String::Utf8Value name_utf8val(isolate, name);
+      const char* name_cstr = ToCString(name_utf8val);
+      // TODO use format string.
+      src.append("export const ");
+      src.append(name_cstr);
+      src.append(" = g.libdeno.builtinModules.");
+      src.append(specifier_cstr);
+      src.append(".");
+      src.append(name_cstr);
+      src.append(";\n");
+    }
+    auto export_str = v8_str(src.c_str(), true);
+
+    auto module =
+        CompileModule(context, specifier_cstr, export_str).ToLocalChecked();
+    auto maybe_ok = module->InstantiateModule(context, ResolveCallback);
+    CHECK(!maybe_ok.IsNothing());
+
+    return handle_scope.Escape(module);
+  }
+
   int ref_id = referrer->GetIdentityHash();
   std::string referrer_filename = d->module_filename_map_[ref_id];
 
@@ -439,7 +494,7 @@ void DenoIsolate::ResolveOk(const char* filename, const char* source) {
     v8::HandleScope handle_scope(isolate_);
     auto context = context_.Get(isolate_);
     v8::TryCatch try_catch(isolate_);
-    auto maybe_module = CompileModule(context, filename, v8_str(source));
+    auto maybe_module = CompileModule(context, filename, v8_str(source, true));
     if (maybe_module.IsEmpty()) {
       DCHECK(try_catch.HasCaught());
       HandleException(context, try_catch.Exception());
@@ -545,6 +600,11 @@ void InitializeContext(v8::Isolate* isolate, v8::Local<v8::Context> context) {
 
   CHECK(deno_val->SetAccessor(context, deno::v8_str("shared"), Shared)
             .FromJust());
+
+  CHECK(
+      deno_val
+          ->SetAccessor(context, deno::v8_str("builtinModules"), BuiltinModules)
+          .FromJust());
 }
 
 void DenoIsolate::AddIsolate(v8::Isolate* isolate) {

libdeno/internal.h

@@ -45,6 +45,8 @@ class DenoIsolate {
   void ResolveOk(const char* filename, const char* source);
   void ClearModules();
 
+  v8::Local<v8::Object> GetBuiltinModules();
+
   v8::Isolate* isolate_;
   v8::ArrayBuffer::Allocator* array_buffer_allocator_;
   deno_buf shared_;
@@ -63,6 +65,8 @@ class DenoIsolate {
   // Set by deno_resolve_ok
   v8::Persistent<v8::Module> resolve_module_;
 
+  v8::Persistent<v8::Object> builtin_modules_;
+
   v8::Persistent<v8::Context> context_;
   std::map<int32_t, v8::Persistent<v8::Value>> async_data_map_;
   std::map<int, v8::Persistent<v8::Value>> pending_promise_map_;
@@ -108,9 +112,15 @@ void Recv(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Send(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Shared(v8::Local<v8::Name> property,
             const v8::PropertyCallbackInfo<v8::Value>& info);
+void BuiltinModules(v8::Local<v8::Name> property,
+                    const v8::PropertyCallbackInfo<v8::Value>& info);
 static intptr_t external_references[] = {
-    reinterpret_cast<intptr_t>(Print), reinterpret_cast<intptr_t>(Recv),
-    reinterpret_cast<intptr_t>(Send), reinterpret_cast<intptr_t>(Shared), 0};
+    reinterpret_cast<intptr_t>(Print),
+    reinterpret_cast<intptr_t>(Recv),
+    reinterpret_cast<intptr_t>(Send),
+    reinterpret_cast<intptr_t>(Shared),
+    reinterpret_cast<intptr_t>(BuiltinModules),
+    0};
 
 static const deno_buf empty_buf = {nullptr, 0, nullptr, 0};
 

libdeno/libdeno_test.cc

@@ -306,3 +306,28 @@ TEST(LibDenoTest, ModuleSnapshot) {
 
   delete[] test_snapshot.data_ptr;
 }
+
+TEST(LibDenoTest, BuiltinModules) {
+  static int count = 0;
+  auto resolve_cb = [](void* user_data, const char* specifier,
+                       const char* referrer) {
+    EXPECT_STREQ(specifier, "b.js");
+    EXPECT_STREQ(referrer, "c.js");
+    count++;
+    auto d = reinterpret_cast<Deno*>(user_data);
+    deno_resolve_ok(d, "b.js", mod_b);
+  };
+  Deno* d = deno_new(deno_config{0, empty, empty, nullptr, resolve_cb});
+  EXPECT_TRUE(deno_execute(
+      d, d, "setup.js", "libdeno.builtinModules['deno'] = { foo: 'bar' }; \n"));
+  EXPECT_EQ(count, 0);
+  EXPECT_TRUE(
+      deno_execute_mod(d, d, "c.js",
+                       "import { retb } from 'b.js'\n"
+                       "import * as deno from 'deno'\n"
+                       "if (retb() != 'b') throw Error('retb');\n"
+                       // "   libdeno.print('deno ' + JSON.stringify(deno));\n"
+                       "if (deno.foo != 'bar') throw Error('foo');\n"));
+  EXPECT_EQ(count, 1);
+  deno_delete(d);
+}