meta: merge node/master into node-chakracore/master

Merge 77b52fd as of 2018-04-07
This commit was automatically generated. For any problems, please contact jackhorton

Reviewed-By: chakrabot <chakrabot@users.noreply.github.com>

doc/api/buffer.md

@@ -1164,16 +1164,17 @@ changes:
     description: The `encoding` parameter is supported now.
 -->
 
-* `value` {string|Buffer|integer} The value to fill `buf` with.
-* `offset` {integer} Number of bytes to skip before starting to fill `buf`. **Default:** `0`.
-* `end` {integer} Where to stop filling `buf` (not inclusive). **Default:** [`buf.length`].
-* `encoding` {string} If `value` is a string, this is its encoding.
+* `value` {string|Buffer|integer} The value with which to fill `buf`.
+* `offset` {integer} Number of bytes to skip before starting to fill `buf`.
+  **Default:** `0`.
+* `end` {integer} Where to stop filling `buf` (not inclusive). **Default:**
+  [`buf.length`].
+* `encoding` {string} The encoding for `value` if `value` is a string.
   **Default:** `'utf8'`.
 * Returns: {Buffer} A reference to `buf`.
 
 Fills `buf` with the specified `value`. If the `offset` and `end` are not given,
-the entire `buf` will be filled. This is meant to be a small simplification to
-allow the creation and filling of a `Buffer` to be done on a single line.
+the entire `buf` will be filled:
 
 ```js
 // Fill a `Buffer` with the ASCII character 'h'.
@@ -1184,10 +1185,10 @@ console.log(b.toString());
 // Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
 ```
 
-`value` is coerced to a `uint32` value if it is not a String or Integer.
+`value` is coerced to a `uint32` value if it is not a string or integer.
 
 If the final write of a `fill()` operation falls on a multi-byte character,
-then only the first bytes of that character that fit into `buf` are written.
+then only the bytes of that character that fit into `buf` are written:
 
 ```js
 // Fill a `Buffer` with a two-byte character.

doc/api/errors.md

@@ -1242,6 +1242,12 @@ An attempt was made to open an IPC communication channel with a synchronously
 forked Node.js process. See the documentation for the [`child_process`][] module
 for more information.
 
+<a id="ERR_MEMORY_ALLOCATION_FAILED"></a>
+### ERR_MEMORY_ALLOCATION_FAILED
+
+An attempt was made to allocate memory (usually in the C++ layer) but it
+failed.
+
 <a id="ERR_METHOD_NOT_IMPLEMENTED"></a>
 ### ERR_METHOD_NOT_IMPLEMENTED
 
@@ -1468,6 +1474,12 @@ additional details.
 A stream method was called that cannot complete because the stream was
 destroyed using `stream.destroy()`.
 
+<a id="ERR_STRING_TOO_LARGE"></a>
+### ERR_STRING_TOO_LARGE
+
+An attempt has been made to create a string larger than the maximum allowed
+size.
+
 <a id="ERR_TLS_CERT_ALTNAME_INVALID"></a>
 ### ERR_TLS_CERT_ALTNAME_INVALID
 

doc/api/fs.md

@@ -4716,6 +4716,7 @@ The following constants are meant for use with the [`fs.Stats`][] object's
 [`fs.access()`]: #fs_fs_access_path_mode_callback
 [`fs.chmod()`]: #fs_fs_chmod_path_mode_callback
 [`fs.chown()`]: #fs_fs_chown_path_uid_gid_callback
+[`fs.copyFile()`]: #fs_fs_copyfile_src_dest_flags_callback
 [`fs.exists()`]: fs.html#fs_fs_exists_path_callback
 [`fs.fstat()`]: #fs_fs_fstat_fd_callback
 [`fs.futimes()`]: #fs_fs_futimes_fd_atime_mtime_callback

doc/api/http2.md

@@ -1538,6 +1538,18 @@ added: v8.4.0
 The `'timeout'` event is emitted when there is no activity on the Server for
 a given number of milliseconds set using `http2server.setTimeout()`.
 
+#### server.close([callback])
+<!-- YAML
+added: v8.4.0
+-->
+- `callback` {Function}
+
+Stops the server from accepting new connections.  See [`net.Server.close()`][].
+
+Note that this is not analogous to restricting new requests since HTTP/2
+connections are persistent. To achieve a similar graceful shutdown behavior,
+consider also using [`http2session.close()`] on active sessions.
+
 ### Class: Http2SecureServer
 <!-- YAML
 added: v8.4.0
@@ -1645,6 +1657,18 @@ negotiate an allowed protocol (i.e. HTTP/2 or HTTP/1.1). The event handler
 receives the socket for handling. If no listener is registered for this event,
 the connection is terminated. See the [Compatibility API][].
 
+#### server.close([callback])
+<!-- YAML
+added: v8.4.0
+-->
+- `callback` {Function}
+
+Stops the server from accepting new connections.  See [`tls.Server.close()`][].
+
+Note that this is not analogous to restricting new requests since HTTP/2
+connections are persistent. To achieve a similar graceful shutdown behavior,
+consider also using [`http2session.close()`] on active sessions.
+
 ### http2.createServer(options[, onRequestHandler])
 <!-- YAML
 added: v8.4.0
@@ -3121,7 +3145,9 @@ following additional properties:
 [`http2.createSecureServer()`]: #http2_http2_createsecureserver_options_onrequesthandler
 [`http2.Server`]: #http2_class_http2server
 [`http2.createServer()`]: #http2_http2_createserver_options_onrequesthandler
+[`http2session.close()`]: #http2_http2session_close_callback
 [`http2stream.pushStream()`]: #http2_http2stream_pushstream_headers_options_callback
+[`net.Server.close()`]: net.html#net_server_close_callback
 [`net.Socket`]: net.html#net_class_net_socket
 [`net.Socket.prototype.ref`]: net.html#net_socket_ref
 [`net.Socket.prototype.unref`]: net.html#net_socket_unref
@@ -3134,6 +3160,7 @@ following additional properties:
 [`response.write(data, encoding)`]: http.html#http_response_write_chunk_encoding_callback
 [`response.writeContinue()`]: #http2_response_writecontinue
 [`response.writeHead()`]: #http2_response_writehead_statuscode_statusmessage_headers
+[`tls.Server.close()`]: tls.html#tls_server_close_callback
 [`tls.TLSSocket`]: tls.html#tls_class_tls_tlssocket
 [`tls.connect()`]: tls.html#tls_tls_connect_options_callback
 [`tls.createServer()`]: tls.html#tls_tls_createserver_options_secureconnectionlistener

doc/api/util.md

@@ -511,7 +511,7 @@ console.log(util.inspect(o, { compact: false, breakLength: 80 }));
 
 Using the `showHidden` option allows to inspect [`WeakMap`][] and [`WeakSet`][]
 entries. If there are more entries than `maxArrayLength`, there is no guarantee
-which entries are displayed. That means retrieving the same ['WeakSet'][]
+which entries are displayed. That means retrieving the same [`WeakSet`][]
 entries twice might actually result in a different output. Besides this any item
 might be collected at any point of time by the garbage collector if there is no
 strong reference left to that object. Therefore there is no guarantee to get a

doc/guides/writing-tests.md

@@ -380,11 +380,17 @@ and tearing it down after the tests have finished.
 It also contains a helper to create arguments to be passed into Node.js. It
 will depend on what is being tested if this is required or not.
 
+### Test Coverage
+
+To generate a test coverage report, see the
+[Test Coverage section of the Pull Requests guide][].
+
 [ASCII]: http://man7.org/linux/man-pages/man7/ascii.7.html
 [Google Test]: https://github.com/google/googletest
 [Web Platform Tests Project]: https://github.com/w3c/web-platform-tests/tree/master/url
 [`common` module]: https://github.com/nodejs/node/blob/master/test/common/README.md
 [all maintained branches]: https://github.com/nodejs/lts
 [node.green]: http://node.green/
 [test fixture]: https://github.com/google/googletest/blob/master/googletest/docs/Primer.md#test-fixtures-using-the-same-data-configuration-for-multiple-tests
+[Test Coverage section of the Pull Requests guide]: https://github.com/nodejs/node/blob/master/doc/guides/contributing/pull-requests.md#test-coverage
 [directory structure overview]: https://github.com/nodejs/node/blob/master/test/README.md#test-directories

lib/_http_server.js

@@ -560,7 +560,7 @@ function resOnFinish(req, res, socket, state, server) {
   // if the user never called req.read(), and didn't pipe() or
   // .resume() or .on('data'), then we call req._dump() so that the
   // bytes will be pulled off the wire.
-  if (!req._consuming && !req._readableState.resumeScheduled)
+  if (!req._readableState.resumeScheduled)
     req._dump();
 
   res.detachSocket(socket);

lib/internal/modules/esm/create_dynamic_module.js

@@ -32,7 +32,7 @@ const createDynamicModule = (exports, url = '', evaluate) => {
   }));`;
   const reflectiveModule = new ModuleWrap(src, `cjs-facade:${url}`);
   reflectiveModule.instantiate();
-  const { setExecutor, reflect } = reflectiveModule.evaluate()();
+  const { setExecutor, reflect } = reflectiveModule.evaluate(-1, false)();
   // public exposed ESM
   const reexports = `
   import {

lib/internal/modules/esm/module_job.js

@@ -103,7 +103,7 @@ class ModuleJob {
   async run() {
     const module = await this.instantiate();
     try {
-      module.evaluate();
+      module.evaluate(-1, false);
     } catch (e) {
       e.stack;
       this.hadError = true;

lib/internal/vm/module.js

@@ -3,9 +3,10 @@
 const { internalBinding } = require('internal/bootstrap/loaders');
 const { emitExperimentalWarning } = require('internal/util');
 const { URL } = require('internal/url');
-const { kParsingContext, isContext } = process.binding('contextify');
+const { isContext } = process.binding('contextify');
 const {
   ERR_INVALID_ARG_TYPE,
+  ERR_OUT_OF_RANGE,
   ERR_VM_MODULE_ALREADY_LINKED,
   ERR_VM_MODULE_DIFFERENT_CONTEXT,
   ERR_VM_MODULE_LINKING_ERRORED,
@@ -55,23 +56,26 @@ class Module {
     if (typeof src !== 'string')
       throw new ERR_INVALID_ARG_TYPE('src', 'string', src);
     if (typeof options !== 'object' || options === null)
-      throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
+      throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
 
-    let context;
-    if (options.context !== undefined) {
-      if (typeof options.context !== 'object' || options.context === null) {
-        throw new ERR_INVALID_ARG_TYPE('options.context', 'object',
-                                       options.context);
+    const {
+      context,
+      lineOffset = 0,
+      columnOffset = 0,
+      initializeImportMeta
+    } = options;
+
+    if (context !== undefined) {
+      if (typeof context !== 'object' || context === null) {
+        throw new ERR_INVALID_ARG_TYPE('options.context', 'Object', context);
       }
-      if (isContext(options.context)) {
-        context = options.context;
-      } else {
-        throw new ERR_INVALID_ARG_TYPE('options.context',
-                                       'vm.Context', options.context);
+      if (!isContext(context)) {
+        throw new ERR_INVALID_ARG_TYPE('options.context', 'vm.Context',
+                                       context);
       }
     }
 
-    let url = options.url;
+    let { url } = options;
     if (url !== undefined) {
       if (typeof url !== 'string') {
         throw new ERR_INVALID_ARG_TYPE('options.url', 'string', url);
@@ -88,22 +92,19 @@ class Module {
       perContextModuleId.set(context, 1);
     }
 
-    if (options.initializeImportMeta !== undefined) {
-      if (typeof options.initializeImportMeta === 'function') {
-        initImportMetaMap.set(this, options.initializeImportMeta);
+    validateInteger(lineOffset, 'options.lineOffset');
+    validateInteger(columnOffset, 'options.columnOffset');
+
+    if (initializeImportMeta !== undefined) {
+      if (typeof initializeImportMeta === 'function') {
+        initImportMetaMap.set(this, initializeImportMeta);
       } else {
         throw new ERR_INVALID_ARG_TYPE(
-          'options.initializeImportMeta', 'function',
-          options.initializeImportMeta);
+          'options.initializeImportMeta', 'function', initializeImportMeta);
       }
     }
 
-    const wrap = new ModuleWrap(src, url, {
-      [kParsingContext]: context,
-      lineOffset: options.lineOffset,
-      columnOffset: options.columnOffset
-    });
-
+    const wrap = new ModuleWrap(src, url, context, lineOffset, columnOffset);
     wrapMap.set(this, wrap);
     linkingStatusMap.set(this, 'unlinked');
     wrapToModuleMap.set(wrap, this);
@@ -194,7 +195,25 @@ class Module {
     wrap.instantiate();
   }
 
-  async evaluate(options) {
+  async evaluate(options = {}) {
+    if (typeof options !== 'object' || options === null) {
+      throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
+    }
+
+    let timeout = options.timeout;
+    if (timeout === undefined) {
+      timeout = -1;
+    } else if (!Number.isInteger(timeout) || timeout <= 0) {
+      throw new ERR_INVALID_ARG_TYPE('options.timeout', 'a positive integer',
+                                     timeout);
+    }
+
+    const { breakOnSigint = false } = options;
+    if (typeof breakOnSigint !== 'boolean') {
+      throw new ERR_INVALID_ARG_TYPE('options.breakOnSigint', 'boolean',
+                                     breakOnSigint);
+    }
+
     const wrap = wrapMap.get(this);
     const status = wrap.getStatus();
     if (status !== kInstantiated &&
@@ -204,7 +223,7 @@ class Module {
         'must be one of instantiated, evaluated, and errored'
       );
     }
-    const result = wrap.evaluate(options);
+    const result = wrap.evaluate(timeout, breakOnSigint);
     return { result, __proto__: null };
   }
 
@@ -224,6 +243,15 @@ class Module {
   }
 }
 
+function validateInteger(prop, propName) {
+  if (!Number.isInteger(prop)) {
+    throw new ERR_INVALID_ARG_TYPE(propName, 'integer', prop);
+  }
+  if ((prop >> 0) !== prop) {
+    throw new ERR_OUT_OF_RANGE(propName, '32-bit integer', prop);
+  }
+}
+
 module.exports = {
   Module,
   initImportMetaMap,

node.gyp

@@ -328,6 +328,7 @@
         'src/node_contextify.cc',
         'src/node_debug_options.cc',
         'src/node_domain.cc',
+        'src/node_errors.h',
         'src/node_file.cc',
         'src/node_http2.cc',
         'src/node_http_parser.cc',