wip

lib/internal/modules/cjs/loader.js

@@ -651,14 +651,13 @@ Module.prototype._compile = function(content, filename) {
 
   content = stripShebang(content);
 
-  // create wrapper function
-  var wrapper = Module.wrap(content);
-
-  var compiledWrapper = vm.runInThisContext(wrapper, {
-    filename: filename,
-    lineOffset: 0,
-    displayErrors: true
-  });
+  const compiledWrapper = vm.compileFunction(content, [
+    'exports',
+    'require',
+    'module',
+    '__filename',
+    '__dirname',
+  ], { filename });
 
   var inspectorWrapper = null;
   if (process._breakFirstLine && process._eval == null) {

lib/vm.js

@@ -26,6 +26,7 @@ const {
   kParsingContext,
   makeContext,
   isContext: _isContext,
+  compileFunction: _compileFunction
 } = process.binding('contextify');
 
 const { ERR_INVALID_ARG_TYPE } = require('internal/errors').codes;
@@ -286,6 +287,36 @@ function runInThisContext(code, options) {
   return createScript(code, options).runInThisContext(options);
 }
 
+function compileFunction(code, params, options) {
+  const defaults = {
+    filename: '',
+    columnOffset: 0,
+    lineOffset: 0,
+    cachedData: undefined,
+    produceCachedData: false,
+    parsingContext: undefined
+  };
+  const {
+    filename,
+    columnOffset,
+    lineOffset,
+    cachedData,
+    produceCachedData,
+    parsingContext,
+  } = Object.assign(defaults, options);
+
+  return _compileFunction(
+    code,
+    filename,
+    lineOffset,
+    columnOffset,
+    cachedData,
+    produceCachedData,
+    parsingContext,
+    params
+  );
+}
+
 module.exports = {
   Script,
   createContext,
@@ -294,6 +325,7 @@ module.exports = {
   runInNewContext,
   runInThisContext,
   isContext,
+  compileFunction,
 };
 
 if (process.binding('config').experimentalVMModules)

src/node_contextify.cc

@@ -207,6 +207,7 @@ void ContextifyContext::Init(Environment* env, Local<Object> target) {
 
   env->SetMethod(target, "makeContext", MakeContext);
   env->SetMethod(target, "isContext", IsContext);
+  env->SetMethod(target, "compileFunction", CompileFunction);
 }
 
 
@@ -951,6 +952,120 @@ class ContextifyScript : public BaseObject {
 };
 
 
+void ContextifyContext::CompileFunction(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+  Local<Context> context = env->context();
+
+  // Argument 1: source code
+  CHECK(args[0]->IsString());
+  Local<String> code = args[0].As<String>();
+
+  // Argument 2: filename
+  CHECK(args[1]->IsString());
+  Local<String> filename = args[1].As<String>();
+
+  // Argument 3: line offset
+  CHECK(args[2]->IsNumber());
+  Local<Integer> line_offset = args[2].As<Integer>();
+
+  // Argument 4: column offset
+  CHECK(args[3]->IsNumber());
+  Local<Integer> column_offset = args[3].As<Integer>();
+
+  // Argument 5: cached data (optional)
+  Local<Uint8Array> cached_data_buf;
+  if (!args[4]->IsUndefined()) {
+    CHECK(args[4]->IsUint8Array());
+    cached_data_buf = args[4].As<Uint8Array>();
+  }
+
+  // Argument 6: produce cache data
+  CHECK(args[5]->IsBoolean());
+  bool produce_cached_data = args[5]->IsTrue();
+
+  // Argument 7: parsing context (optional)
+  Local<Context> parsing_context;
+  if (!args[6]->IsUndefined()) {
+    CHECK(args[6]->IsObject());
+    ContextifyContext* sandbox =
+      ContextifyContext::ContextFromContextifiedSandbox(
+          env, args[6].As<Object>());
+    CHECK_NOT_NULL(sandbox);
+    parsing_context = sandbox->context();
+  } else {
+    parsing_context = context;
+  }
+
+  // Argument 8: params for the function (optional)
+  Local<Array> params_buf;
+  if (!args[7]->IsUndefined()) {
+    CHECK(args[7]->IsArray());
+    params_buf = args[7].As<Array>();
+  }
+
+  // Read cache from cached data buffer
+  ScriptCompiler::CachedData* cached_data = nullptr;
+  if (!cached_data_buf.IsEmpty()) {
+    ArrayBuffer::Contents contents = cached_data_buf->Buffer()->GetContents();
+    uint8_t* data = static_cast<uint8_t*>(contents.Data());
+    cached_data = new ScriptCompiler::CachedData(
+      data + cached_data_buf->ByteOffset(), cached_data_buf->ByteLength());
+  }
+
+  ScriptOrigin origin(filename, line_offset, column_offset);
+  ScriptCompiler::Source source(code, origin, cached_data);
+  ScriptCompiler::CompileOptions options;
+  if (source.GetCachedData() == nullptr) {
+    options = ScriptCompiler::kNoCompileOptions;
+  } else {
+    options = ScriptCompiler::kConsumeCodeCache;
+  }
+
+  TryCatch try_catch(isolate);
+  Context::Scope scope(parsing_context);
+
+  // Read params from params buffer
+  std::vector<Local<String>> params;
+  if (!params_buf.IsEmpty()) {
+    for (uint32_t n = 0; n < params_buf->Length(); n++) {
+      Local<Value> val = params_buf->Get(context, n).ToLocalChecked();
+      CHECK(val->IsString());
+      params.push_back(val.As<String>());
+    }
+  }
+
+  MaybeLocal<Function> maybe_fun = ScriptCompiler::CompileFunctionInContext(
+      context, &source, params.size(), params.data(), 0, nullptr, options);
+
+  Local<Function> fun;
+  if (maybe_fun.IsEmpty() || !maybe_fun.ToLocal(&fun)) {
+    ContextifyScript::DecorateErrorStack(env, try_catch);
+    try_catch.ReThrow();
+    return;
+  }
+
+  if (produce_cached_data) {
+    const ScriptCompiler::CachedData* cached_data =
+      ScriptCompiler::CreateCodeCacheForFunction(fun, code);
+    bool cached_data_produced = cached_data != nullptr;
+    if (cached_data_produced) {
+      MaybeLocal<Object> buf = Buffer::Copy(
+          env,
+          reinterpret_cast<const char*>(cached_data->data),
+          cached_data->length);
+      fun->Set(env->cached_data_string(), buf.ToLocalChecked());
+    }
+    fun->Set(
+        env->cached_data_produced_string(),
+        Boolean::New(isolate, cached_data_produced));
+  }
+
+  args.GetReturnValue().Set(fun);
+}
+
+
 void Initialize(Local<Object> target,
                 Local<Value> unused,
                 Local<Context> context) {

src/node_contextify.h

@@ -55,6 +55,8 @@ class ContextifyContext {
  private:
   static void MakeContext(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void IsContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetWrappedFunction(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   static void WeakCallback(
       const v8::WeakCallbackInfo<ContextifyContext>& data);
   static void PropertyGetterCallback(

test/parallel/test-vm-basic.js

@@ -128,3 +128,30 @@ const vm = require('vm');
              'Received type object'
   });
 });
+
+// vm.compileFunction
+{
+  assert.strictEqual(
+    vm.compileFunction('console.log("Hello, World!")').toString(),
+    'function () {\nconsole.log("Hello, World!")\n}'
+  );
+
+  assert.strictEqual(
+    vm.compileFunction(
+      'return p + q + r + s + t',
+      ['p', 'q', 'r', 's', 't']
+    )('ab', 'cd', 'ef', 'gh', 'ij'),
+    'abcdefghij'
+  );
+
+  vm.compileFunction('return'); // Should not throw on 'return'
+
+  common.expectsError(() => {
+    vm.compileFunction(
+      '});\n\n(function() {\nconsole.log(1);\n})();\n\n(function() {'
+    );
+  }, {
+    type: SyntaxError,
+    message: 'Unexpected token }'
+  });
+}