v8: introduce v8.emitCodeGenFromStringEvent()

doc/api/v8.md

@@ -503,6 +503,36 @@ added: v8.0.0
 A subclass of [`Deserializer`][] corresponding to the format written by
 [`DefaultSerializer`][].
 
+## `v8.emitCodeGenFromStringEvent()`
+<!-- YAML
+added: REPLACEME
+-->
+
+After this methode is called, calling `eval(code)` or `new Function(code)`
+will emit a `codeGenerationFromString` event on `process` with the value
+of `code`. The call to `eval` or `new Function` will happen after the
+event is emitted.
+
+Calls to the `vm` module such as `vm.runInContext` will not emit the event.
+
+Calling `v8.emitCodeGenFromStringEvent()` when the
+`--disallow-code-generation-from-strings` flag is used will be a noop.
+
+```js
+const v8 = require('v8');
+v8.emitCodeGenFromStringEvent();
+process.on('codeGenerationFromString', (code) => {
+  console.log('Generating code from string`', code, '`');
+});
+const item = { foo: 0 };
+eval('item.foo++');
+```
+
+will log
+```text
+Generating code from string` item.foo++ `
+```
+
 [`Buffer`]: buffer.html
 [`DefaultDeserializer`]: #v8_class_v8_defaultdeserializer
 [`DefaultSerializer`]: #v8_class_v8_defaultserializer

lib/v8.js

@@ -72,6 +72,7 @@ class Deserializer extends _Deserializer { }
 
 const {
   cachedDataVersionTag,
+  emitCodeGenFromStringEvent,
   setFlagsFromString: _setFlagsFromString,
   heapStatisticsBuffer,
   heapSpaceStatisticsBuffer,
@@ -265,6 +266,7 @@ function deserialize(buffer) {
 
 module.exports = {
   cachedDataVersionTag,
+  emitCodeGenFromStringEvent,
   getHeapSnapshot,
   getHeapStatistics,
   getHeapSpaceStatistics,

src/node_v8.cc

@@ -25,6 +25,7 @@
 #include "memory_tracker-inl.h"
 #include "util-inl.h"
 #include "v8.h"
+#include "node_process.h"
 
 namespace node {
 
@@ -167,6 +168,29 @@ void SetFlagsFromString(const FunctionCallbackInfo<Value>& args) {
   V8::SetFlagsFromString(*flags, static_cast<size_t>(flags.length()));
 }
 
+static v8::ModifyCodeGenerationFromStringsResult CodeGenCallback(
+                                                         Local<Context> context,
+                                                         Local<Value> source) {
+  Environment* env = Environment::GetCurrent(context);
+  ProcessEmit(env, "codeGenerationFromString", source);
+  // expected signature is {bool, Local<Value>} but {bool} is also valid and
+  // fallbacks on the original argument.
+  return {true};
+}
+
+static void EmitCodeGenFromStringEvent(
+                                      const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = args.GetIsolate();
+  Local<Context> context = env->context();
+
+  // This only makes sense if code generation from string is allowed.
+  if (context->IsCodeGenerationFromStringsAllowed()) {
+    // V8 requires that this is set to false for it to call the callback
+    context->AllowCodeGenerationFromStrings(false);
+    isolate->SetModifyCodeGenerationFromStringsCallback(CodeGenCallback);
+  }
+}
 
 void Initialize(Local<Object> target,
                 Local<Value> unused,
@@ -180,6 +204,9 @@ void Initialize(Local<Object> target,
   env->SetMethodNoSideEffect(target, "cachedDataVersionTag",
                              CachedDataVersionTag);
 
+  env->SetMethod(
+         target, "emitCodeGenFromStringEvent", EmitCodeGenFromStringEvent);
+
   // Export symbols used by v8.getHeapStatistics()
   env->SetMethod(
       target, "updateHeapStatisticsBuffer", UpdateHeapStatisticsBuffer);

test/parallel/test-v8-codegen-from-string.js

@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const v8 = require('v8');
+
+const beforeSetupHandler =
+    common.mustNotCall('called before v8.emitCodeGenFromStringEvent()');
+
+process.on('codeGenerationFromString', beforeSetupHandler);
+
+const item = { foo: 0 };
+eval('++item.foo');
+process.off('codeGenerationFromString', beforeSetupHandler);
+
+assert.strictEqual(item.foo, 1);
+
+v8.emitCodeGenFromStringEvent();
+process.on('codeGenerationFromString', common.mustCall((code) => {
+  assert.strictEqual(code, 'item.foo++');
+}));
+
+eval('item.foo++');
+assert.strictEqual(item.foo, 2);